package com.sg.service.biz.calc.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.sg.common.util.CommonFunctionHelper;
import com.sg.common.util.RedisUtil;
import com.sg.dto.base.calc.req.*;
import com.sg.dto.biz.calc.req.*;
import com.sg.dto.biz.calc.res.*;
import com.sg.dto.integration.component.ImplementDebugBusinessDataRedisComReqDto;
import com.sg.dto.integration.component.ImplementDebugBusinessDataRedisComRespDto;
import com.sg.service.base.calc.MOmsStandardDataResultService;
import com.sg.service.biz.calc.StandardDataService;
import com.sg.service.biz.calc.TargetCalcService;
import com.wicket.okrapp.integration.*;
import com.wicket.okrapp.integration.dto.*;
import com.sg.common.exception.Assert;
import com.wicket.okrcomponent.integration.FwCompBusinessAtomClient;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author ：
 * @version 1.0
 * @date ：
 */
@Service
public class SystemTestDomainServiceImpl implements com.wicket.okrcalc.biz.service.SystemTestDomainService {
    @Resource
    private RedisUtil redisUtil;
    @Resource
    private MOmsStandardDataResultService mOmsStandardDataResultService;
    //@Resource
    //private MCustomFieldsService mCustomFieldsService;
    @Resource
    private NbSystemTestDomain nbSystemTestDomain;
    //@Resource
    //private undefinedService undefinedService;
    @Resource
    private TargetCalcService fwAppTargetCalcClient;
    @Resource
    private StandardDataService standardDataService;
    @Resource
    private TargetCalcService targetCalcService;
    @Resource
    private SystemTestDomainService fwAppSystemTestDomainClient;
    @Resource
    private FwAppExecuteCycleClient fwAppExecuteCycleClient;
    @Resource
    private VirtualOrgService fwAppVirtualOrgClient;
    @Resource
    private FwCompBusinessAtomClient fwCompBusinessAtomClient;
    @Resource
    private IndexSystemService fwAppIndexSystemClient;
//@Resource
    //private MOmsTargetAttributionCycleService mOmsTargetAttributionCycleService;

    /**
     * D4-构造单条被评对象目标周期标准数据验证数据(公共)[4256]
     * gen by moon at 9/12/2022, 6:25:55 PM
     */
    @Trace(operationName = "D4-构造单条被评对象目标周期标准数据验证数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BuildSingleEvaObjTarCycStaDataComRespDto buildSingleEvaObjTarCycStaDataCom(BuildSingleEvaObjTarCycStaDataComReqDto reqDto) {


        String string_1 = null;
//步骤0: M-构造被评对象目标周期标准数据验证数据 - buildEvaObjTarCycStaData
        String string = null;
        OmsStandardDataResult omsStandardDataResult = new OmsStandardDataResult();
        if (reqDto != null) {
            omsStandardDataResult.setDataResult(reqDto.getDataResult());//sourceId:266157_1
            omsStandardDataResult.setResultType(reqDto.getResultType());//sourceId:276913_1
            omsStandardDataResult.setParentDataResultId(reqDto.getParentDataResultId());//sourceId:266158_1
            omsStandardDataResult.setParentDataResult(reqDto.getParentDataResult());//sourceId:266159_1
            omsStandardDataResult.setUnit(reqDto.getUnit());//sourceId:266160_1
            omsStandardDataResult.setIsNewData(reqDto.getIsNewData());//sourceId:276914_1
            omsStandardDataResult.setPeriodId(reqDto.getPeriodId());//sourceId:266161_1
            omsStandardDataResult.setCycleStartTime(reqDto.getCycleStartTime());//sourceId:266162_1
            omsStandardDataResult.setCycleEndTime(reqDto.getCycleEndTime());//sourceId:266163_1
            omsStandardDataResult.setCycleTypeCode(reqDto.getCycleTypeCode());//sourceId:266164_1
            omsStandardDataResult.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//sourceId:266165_1
            omsStandardDataResult.setDataType(reqDto.getDataType());//sourceId:266166_1
            omsStandardDataResult.setTableTypeCode(reqDto.getTableTypeCode());//sourceId:266167_1
            omsStandardDataResult.setEntityId(reqDto.getEntityId());//sourceId:266168_1
            omsStandardDataResult.setFromContentTableTypeCode(reqDto.getFromContentTableTypeCode());//sourceId:266169_1
            omsStandardDataResult.setFromContentEntityId(reqDto.getFromContentEntityId());//sourceId:266170_1
            omsStandardDataResult.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//sourceId:301686_1
            omsStandardDataResult.setBelongToContentId(reqDto.getBelongToContentId());//sourceId:301687_1
            omsStandardDataResult.setPersonLiableObjId(reqDto.getPersonLiableObjId());//sourceId:266171_1
            omsStandardDataResult.setBizRoleObjId(reqDto.getBizRoleObjId());//sourceId:266172_1
            omsStandardDataResult.setBizRoleObjCode(reqDto.getBizRoleObjCode());//sourceId:266173_1
            omsStandardDataResult.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//sourceId:266174_1
            omsStandardDataResult.setBizRoleObjName(reqDto.getBizRoleObjName());//sourceId:266175_1
        }

        /*M-构造被评对象目标周期标准数据验证数据[4255]   */
        Assert.isNull(omsStandardDataResult.getDataResult(), "D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-数据值结果不能为空", false);
        Assert.isNull(omsStandardDataResult.getResultType(), "D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-结果产生类型 不能为空", false);
        Assert.isNull(omsStandardDataResult.getIsNewData(), "D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-是否最新数据不能为空", false);
        Assert.isNull(omsStandardDataResult.getPeriodId(), "D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-周期ID不能为空", false);
        Assert.isNull(omsStandardDataResult.getCycleStartTime(), "D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-周期开始时间不能为空", false);
        Assert.isNull(omsStandardDataResult.getCycleEndTime(), "D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-周期结束时间不能为空", false);
        Assert.isNull(omsStandardDataResult.getCycleTypeCode(), "D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-周期类型标识不能为空", false);
        Assert.isNull(omsStandardDataResult.getDataType(), "D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-数据类型编码不能为空", false);
        Assert.isNull(omsStandardDataResult.getTableTypeCode(), "D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-归属内容表类型编码不能为空", false);
        Assert.isNull(omsStandardDataResult.getEntityId(), "D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-归属内容表主键ID不能为空", false);
        Assert.isNull(omsStandardDataResult.getPersonLiableObjId(), "D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-填报评价责任人对象ID不能为空", false);
        Assert.isNull(omsStandardDataResult.getBizRoleObjId(), "D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-填报评价责任人业务角色对象ID不能为空", false);
        Assert.isNull(omsStandardDataResult.getBizRoleObjCode(), "D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-填报评价责任人业务角色标识不能为空", false);
        Assert.isNull(omsStandardDataResult.getPersonLiableTypeCode(), "D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-填报评价责任人身份类型编码不能为空", false);
        Assert.isNull(omsStandardDataResult.getBizRoleObjName(), "D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-填报评价责任人业务角色对象名称不能为空", false);
        string = mOmsStandardDataResultService.buildEvaObjTarCycStaData(omsStandardDataResult);


        string_1 = string;

        BuildSingleEvaObjTarCycStaDataComRespDto retData = new BuildSingleEvaObjTarCycStaDataComRespDto();
        if (string_1 != null) {
            retData.setDataResultId(string_1);//sourceId:276067_1
        }


        return retData;
    }

    /**
     * D4-构造多条被评对象目标周期标准数据验证数据(公共)[4305]
     * gen by moon at 9/12/2022, 6:26:06 PM
     */
    @Trace(operationName = "D4-构造多条被评对象目标周期标准数据验证数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BuildMultiEvaObjTarCycStaDataComRespDto buildMultiEvaObjTarCycStaDataCom(BuildMultiEvaObjTarCycStaDataComReqDto reqDto) {


        //步骤0: M4-执行接收字段（特殊方法） - implementReceiveField
        //ModelCode: receptionService
        ImplementReceiveFieldRespDto receptionServiceRes = null;
        ImplementReceiveFieldReqDto receptionServiceReq = new ImplementReceiveFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//sourceId:279771_1
            receptionServiceReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//sourceId:301692_1
            receptionServiceReq.setPersonLiableObjId(reqDto.getPersonLiableObjId());//sourceId:279722_1
            receptionServiceReq.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//sourceId:301693_1
            receptionServiceReq.setBizRoleObjId(reqDto.getBizRoleObjId());//sourceId:279723_1
            receptionServiceReq.setBizRoleObjName(reqDto.getBizRoleObjName());//sourceId:279724_1
            receptionServiceReq.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//sourceId:279725_1
            receptionServiceReq.setBizRoleObjCode(reqDto.getBizRoleObjCode());//sourceId:279726_1
            receptionServiceReq.setActualValue(reqDto.getActualValue());//sourceId:279721_1
            receptionServiceReq.setActualValueUnit(reqDto.getActualValueUnit());//sourceId:279720_1
            receptionServiceReq.setCycleId(reqDto.getCycleId());//sourceId:279772_1
            receptionServiceReq.setCycleTypeCode(reqDto.getCycleTypeCode());//sourceId:279773_1
            receptionServiceReq.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//sourceId:279774_1
            receptionServiceReq.setCycleStageDataId(reqDto.getCycleStageDataId());//sourceId:279775_1
            receptionServiceReq.setProgressValue(reqDto.getProgressValue());//sourceId:279741_1
            receptionServiceReq.setCycleStartTime(reqDto.getCycleStartTime());//sourceId:279776_1
            receptionServiceReq.setCycleEndTime(reqDto.getCycleEndTime());//sourceId:279777_1
            receptionServiceReq.setProgressValueUnit(reqDto.getProgressValueUnit());//sourceId:279742_1
            receptionServiceReq.setReach(reqDto.getReach());//sourceId:279745_1
            receptionServiceReq.setActualFromLastTimeRatio(reqDto.getActualFromLastTimeRatio());//sourceId:279746_1
            receptionServiceReq.setReachUnit(reqDto.getReachUnit());//sourceId:279747_1
            receptionServiceReq.setActualFromLastTimeRatioUnit(reqDto.getActualFromLastTimeRatioUnit());//sourceId:279748_1
            receptionServiceReq.setRealTimeScore(reqDto.getRealTimeScore());//sourceId:279750_1
            receptionServiceReq.setRealTimeScoreUnit(reqDto.getRealTimeScoreUnit());//sourceId:279751_1
            receptionServiceReq.setProgressFromLastRatio(reqDto.getProgressFromLastRatio());//sourceId:279743_1
            receptionServiceReq.setProgressFromLastRatioUnit(reqDto.getProgressFromLastRatioUnit());//sourceId:279744_1
        }

        /*M4-执行接收字段（特殊方法）[2950]  用于特殊方法接收上游入参。 */

        receptionServiceRes = nbSystemTestDomain.implementReceiveField(receptionServiceReq);


//步骤1: D4-构造单条被评对象目标周期标准数据验证数据(公共) - buildSingleEvaObjTarCycStaDataCom
        BuildSingleEvaObjTarCycStaDataComRespDto buildSingleEvaObjTarCycStaDataComRespDto = null;
        BuildSingleEvaObjTarCycStaDataComReqDto buildSingleEvaObjTarCycStaDataComReqDto = new BuildSingleEvaObjTarCycStaDataComReqDto();
        buildSingleEvaObjTarCycStaDataComReqDto.setDataType("ACTUAL_VALUE");//sourceId:279436_1
        buildSingleEvaObjTarCycStaDataComReqDto.setResultType("MANUAL_INPUT");//sourceId:279446_1
        buildSingleEvaObjTarCycStaDataComReqDto.setIsNewData("TRUE");//sourceId:279447_1
        buildSingleEvaObjTarCycStaDataComReqDto.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:279437_1
        buildSingleEvaObjTarCycStaDataComReqDto.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:279439_1
        if (reqDto != null) {
            buildSingleEvaObjTarCycStaDataComReqDto.setDataResult(reqDto.getActualValue());//sourceId:279427_1
            buildSingleEvaObjTarCycStaDataComReqDto.setUnit(reqDto.getActualValueUnit());//sourceId:279430_1
            buildSingleEvaObjTarCycStaDataComReqDto.setPeriodId(reqDto.getCycleId());//sourceId:279431_1
            buildSingleEvaObjTarCycStaDataComReqDto.setCycleStartTime(reqDto.getCycleStartTime());//sourceId:279432_1
            buildSingleEvaObjTarCycStaDataComReqDto.setCycleEndTime(reqDto.getCycleEndTime());//sourceId:279433_1
            buildSingleEvaObjTarCycStaDataComReqDto.setCycleTypeCode(reqDto.getCycleTypeCode());//sourceId:279434_1
            buildSingleEvaObjTarCycStaDataComReqDto.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//sourceId:280113_1
            buildSingleEvaObjTarCycStaDataComReqDto.setEntityId(reqDto.getEvaObjTargetCycleId());//sourceId:279438_1
            buildSingleEvaObjTarCycStaDataComReqDto.setFromContentEntityId(reqDto.getCycleStageDataId());//sourceId:279440_1
            buildSingleEvaObjTarCycStaDataComReqDto.setBelongToContentTypeCode(reqDto.getTargetCycleContentTypeCode());//sourceId:301706_1
            buildSingleEvaObjTarCycStaDataComReqDto.setBelongToContentId(reqDto.getTargetCycleContentId());//sourceId:301707_1
            buildSingleEvaObjTarCycStaDataComReqDto.setPersonLiableObjId(reqDto.getPersonLiableObjId());//sourceId:279441_1
            buildSingleEvaObjTarCycStaDataComReqDto.setBizRoleObjId(reqDto.getBizRoleObjId());//sourceId:279442_1
            buildSingleEvaObjTarCycStaDataComReqDto.setBizRoleObjCode(reqDto.getBizRoleObjCode());//sourceId:279443_1
            buildSingleEvaObjTarCycStaDataComReqDto.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//sourceId:279444_1
            buildSingleEvaObjTarCycStaDataComReqDto.setBizRoleObjName(reqDto.getBizRoleObjName());//sourceId:279445_1
        }

        /*D4-构造单条被评对象目标周期标准数据验证数据(实际值)[4256]   */
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getDataType(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-数据类型编码不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getResultType(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-结果产生类型 不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getDataResult(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-数据值结果不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getPeriodId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-周期ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getCycleStartTime(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-周期开始时间不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getCycleEndTime(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-周期结束时间不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getCycleTypeCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-周期类型标识不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getIsNewData(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-是否最新数据不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getTableTypeCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-归属内容表类型编码不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getEntityId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-归属内容表主键ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getFromContentTableTypeCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-来自内容表类型编码不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getPersonLiableObjId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-填报评价责任人对象ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getBizRoleObjId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-填报评价责任人业务角色对象ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getBizRoleObjCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-填报评价责任人业务角色标识不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getPersonLiableTypeCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-填报评价责任人身份类型编码不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getBizRoleObjName(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-填报评价责任人业务角色对象名称不能为空", false);
        buildSingleEvaObjTarCycStaDataComRespDto = buildSingleEvaObjTarCycStaDataCom(buildSingleEvaObjTarCycStaDataComReqDto);


//步骤2: D4-构造单条被评对象目标周期标准数据验证数据(公共) - buildSingleEvaObjTarCycStaDataCom
        BuildSingleEvaObjTarCycStaDataComRespDto buildSingleEvaObjTarCycStaDataComRespDto_2 = null;
        BuildSingleEvaObjTarCycStaDataComReqDto buildSingleEvaObjTarCycStaDataComReqDto_1 = new BuildSingleEvaObjTarCycStaDataComReqDto();
        buildSingleEvaObjTarCycStaDataComReqDto_1.setDataType("PROGRESS_VALUE");//sourceId:279458_1
        buildSingleEvaObjTarCycStaDataComReqDto_1.setResultType("MANUAL_INPUT");//sourceId:279468_1
        buildSingleEvaObjTarCycStaDataComReqDto_1.setIsNewData("TRUE");//sourceId:279469_1
        buildSingleEvaObjTarCycStaDataComReqDto_1.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:279459_1
        buildSingleEvaObjTarCycStaDataComReqDto_1.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:279461_1
        if (reqDto != null) {
            buildSingleEvaObjTarCycStaDataComReqDto_1.setDataResult(reqDto.getProgressValue());//sourceId:279449_1
            buildSingleEvaObjTarCycStaDataComReqDto_1.setUnit(reqDto.getProgressValueUnit());//sourceId:279452_1
            buildSingleEvaObjTarCycStaDataComReqDto_1.setPeriodId(reqDto.getCycleId());//sourceId:279453_1
            buildSingleEvaObjTarCycStaDataComReqDto_1.setCycleStartTime(reqDto.getCycleStartTime());//sourceId:279454_1
            buildSingleEvaObjTarCycStaDataComReqDto_1.setCycleEndTime(reqDto.getCycleEndTime());//sourceId:279455_1
            buildSingleEvaObjTarCycStaDataComReqDto_1.setCycleTypeCode(reqDto.getCycleTypeCode());//sourceId:279456_1
            buildSingleEvaObjTarCycStaDataComReqDto_1.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//sourceId:280116_1
            buildSingleEvaObjTarCycStaDataComReqDto_1.setEntityId(reqDto.getEvaObjTargetCycleId());//sourceId:279460_1
            buildSingleEvaObjTarCycStaDataComReqDto_1.setFromContentEntityId(reqDto.getCycleStageDataId());//sourceId:279462_1
            buildSingleEvaObjTarCycStaDataComReqDto_1.setBelongToContentTypeCode(reqDto.getTargetCycleContentTypeCode());//sourceId:301690_1
            buildSingleEvaObjTarCycStaDataComReqDto_1.setBelongToContentId(reqDto.getTargetCycleContentId());//sourceId:301691_1
            buildSingleEvaObjTarCycStaDataComReqDto_1.setPersonLiableObjId(reqDto.getPersonLiableObjId());//sourceId:279463_1
            buildSingleEvaObjTarCycStaDataComReqDto_1.setBizRoleObjId(reqDto.getBizRoleObjId());//sourceId:279464_1
            buildSingleEvaObjTarCycStaDataComReqDto_1.setBizRoleObjCode(reqDto.getBizRoleObjCode());//sourceId:279465_1
            buildSingleEvaObjTarCycStaDataComReqDto_1.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//sourceId:279466_1
            buildSingleEvaObjTarCycStaDataComReqDto_1.setBizRoleObjName(reqDto.getBizRoleObjName());//sourceId:279467_1
        }

        /*D4-构造单条被评对象目标周期标准数据验证数据(进度值)[4256]   */
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getDataType(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-数据类型编码不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getResultType(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-结果产生类型 不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getDataResult(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-数据值结果不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getPeriodId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-周期ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getCycleStartTime(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-周期开始时间不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getCycleEndTime(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-周期结束时间不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getCycleTypeCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-周期类型标识不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getIsNewData(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-是否最新数据不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getTableTypeCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-归属内容表类型编码不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getEntityId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-归属内容表主键ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getPersonLiableObjId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-填报评价责任人对象ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getBizRoleObjId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-填报评价责任人业务角色对象ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getBizRoleObjCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-填报评价责任人业务角色标识不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getPersonLiableTypeCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-填报评价责任人身份类型编码不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getBizRoleObjName(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-填报评价责任人业务角色对象名称不能为空", false);
        buildSingleEvaObjTarCycStaDataComRespDto_2 = buildSingleEvaObjTarCycStaDataCom(buildSingleEvaObjTarCycStaDataComReqDto_1);


//步骤3: D4-构造单条被评对象目标周期标准数据验证数据(公共) - buildSingleEvaObjTarCycStaDataCom
        BuildSingleEvaObjTarCycStaDataComRespDto buildSingleEvaObjTarCycStaDataComRespDto_4 = null;
        BuildSingleEvaObjTarCycStaDataComReqDto buildSingleEvaObjTarCycStaDataComReqDto_2 = new BuildSingleEvaObjTarCycStaDataComReqDto();
        buildSingleEvaObjTarCycStaDataComReqDto_2.setDataType("PROGRESS_FROM_LAST_RATIO");//sourceId:279480_1
        buildSingleEvaObjTarCycStaDataComReqDto_2.setResultType("SYSTEM_AUTO_COUNT");//sourceId:279490_1
        buildSingleEvaObjTarCycStaDataComReqDto_2.setIsNewData("TRUE");//sourceId:279491_1
        buildSingleEvaObjTarCycStaDataComReqDto_2.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:279481_1
        buildSingleEvaObjTarCycStaDataComReqDto_2.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:279483_1
        if (reqDto != null) {
            buildSingleEvaObjTarCycStaDataComReqDto_2.setDataResult(reqDto.getProgressFromLastRatio());//sourceId:279471_1
            buildSingleEvaObjTarCycStaDataComReqDto_2.setUnit(reqDto.getProgressFromLastRatioUnit());//sourceId:279474_1
            buildSingleEvaObjTarCycStaDataComReqDto_2.setPeriodId(reqDto.getCycleId());//sourceId:279475_1
            buildSingleEvaObjTarCycStaDataComReqDto_2.setCycleStartTime(reqDto.getCycleStartTime());//sourceId:279476_1
            buildSingleEvaObjTarCycStaDataComReqDto_2.setCycleEndTime(reqDto.getCycleEndTime());//sourceId:279477_1
            buildSingleEvaObjTarCycStaDataComReqDto_2.setCycleTypeCode(reqDto.getCycleTypeCode());//sourceId:279478_1
            buildSingleEvaObjTarCycStaDataComReqDto_2.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//sourceId:280124_1
            buildSingleEvaObjTarCycStaDataComReqDto_2.setEntityId(reqDto.getEvaObjTargetCycleId());//sourceId:279482_1
            buildSingleEvaObjTarCycStaDataComReqDto_2.setFromContentEntityId(reqDto.getCycleStageDataId());//sourceId:279484_1
            buildSingleEvaObjTarCycStaDataComReqDto_2.setBelongToContentTypeCode(reqDto.getTargetCycleContentTypeCode());//sourceId:301698_1
            buildSingleEvaObjTarCycStaDataComReqDto_2.setBelongToContentId(reqDto.getTargetCycleContentId());//sourceId:301699_1
            buildSingleEvaObjTarCycStaDataComReqDto_2.setPersonLiableObjId(reqDto.getPersonLiableObjId());//sourceId:279485_1
            buildSingleEvaObjTarCycStaDataComReqDto_2.setBizRoleObjId(reqDto.getBizRoleObjId());//sourceId:279486_1
            buildSingleEvaObjTarCycStaDataComReqDto_2.setBizRoleObjCode(reqDto.getBizRoleObjCode());//sourceId:279487_1
            buildSingleEvaObjTarCycStaDataComReqDto_2.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//sourceId:279488_1
            buildSingleEvaObjTarCycStaDataComReqDto_2.setBizRoleObjName(reqDto.getBizRoleObjName());//sourceId:279489_1
        }

        /*D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)[4256]   */
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getDataType(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-数据类型编码不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getResultType(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-结果产生类型 不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getDataResult(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-数据值结果不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getPeriodId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-周期ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getCycleStartTime(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-周期开始时间不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getCycleEndTime(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-周期结束时间不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getCycleTypeCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-周期类型标识不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getIsNewData(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-是否最新数据不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getTableTypeCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-归属内容表类型编码不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getEntityId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-归属内容表主键ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getPersonLiableObjId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-填报评价责任人对象ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getBizRoleObjId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-填报评价责任人业务角色对象ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getBizRoleObjCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-填报评价责任人业务角色标识不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getPersonLiableTypeCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-填报评价责任人身份类型编码不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getBizRoleObjName(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-填报评价责任人业务角色对象名称不能为空", false);
        buildSingleEvaObjTarCycStaDataComRespDto_4 = buildSingleEvaObjTarCycStaDataCom(buildSingleEvaObjTarCycStaDataComReqDto_2);


//步骤4: D4-构造单条被评对象目标周期标准数据验证数据(公共) - buildSingleEvaObjTarCycStaDataCom
        BuildSingleEvaObjTarCycStaDataComRespDto buildSingleEvaObjTarCycStaDataComRespDto_6 = null;
        BuildSingleEvaObjTarCycStaDataComReqDto buildSingleEvaObjTarCycStaDataComReqDto_3 = new BuildSingleEvaObjTarCycStaDataComReqDto();
        buildSingleEvaObjTarCycStaDataComReqDto_3.setDataType("REACH");//sourceId:279502_1
        buildSingleEvaObjTarCycStaDataComReqDto_3.setResultType("SYSTEM_AUTO_COUNT");//sourceId:279512_1
        buildSingleEvaObjTarCycStaDataComReqDto_3.setIsNewData("TRUE");//sourceId:279513_1
        buildSingleEvaObjTarCycStaDataComReqDto_3.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:279503_1
        buildSingleEvaObjTarCycStaDataComReqDto_3.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:279505_1
        if (reqDto != null) {
            buildSingleEvaObjTarCycStaDataComReqDto_3.setDataResult(reqDto.getReach());//sourceId:279493_1
            buildSingleEvaObjTarCycStaDataComReqDto_3.setUnit(reqDto.getReachUnit());//sourceId:279496_1
            buildSingleEvaObjTarCycStaDataComReqDto_3.setPeriodId(reqDto.getCycleId());//sourceId:279497_1
            buildSingleEvaObjTarCycStaDataComReqDto_3.setCycleStartTime(reqDto.getCycleStartTime());//sourceId:279498_1
            buildSingleEvaObjTarCycStaDataComReqDto_3.setCycleEndTime(reqDto.getCycleEndTime());//sourceId:279499_1
            buildSingleEvaObjTarCycStaDataComReqDto_3.setCycleTypeCode(reqDto.getCycleTypeCode());//sourceId:279500_1
            buildSingleEvaObjTarCycStaDataComReqDto_3.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//sourceId:280125_1
            buildSingleEvaObjTarCycStaDataComReqDto_3.setEntityId(reqDto.getEvaObjTargetCycleId());//sourceId:279504_1
            buildSingleEvaObjTarCycStaDataComReqDto_3.setFromContentEntityId(reqDto.getCycleStageDataId());//sourceId:279506_1
            buildSingleEvaObjTarCycStaDataComReqDto_3.setBelongToContentTypeCode(reqDto.getTargetCycleContentTypeCode());//sourceId:301700_1
            buildSingleEvaObjTarCycStaDataComReqDto_3.setBelongToContentId(reqDto.getTargetCycleContentId());//sourceId:301701_1
            buildSingleEvaObjTarCycStaDataComReqDto_3.setPersonLiableObjId(reqDto.getPersonLiableObjId());//sourceId:279507_1
            buildSingleEvaObjTarCycStaDataComReqDto_3.setBizRoleObjId(reqDto.getBizRoleObjId());//sourceId:279508_1
            buildSingleEvaObjTarCycStaDataComReqDto_3.setBizRoleObjCode(reqDto.getBizRoleObjCode());//sourceId:279509_1
            buildSingleEvaObjTarCycStaDataComReqDto_3.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//sourceId:279510_1
            buildSingleEvaObjTarCycStaDataComReqDto_3.setBizRoleObjName(reqDto.getBizRoleObjName());//sourceId:279511_1
        }

        /*D4-构造单条被评对象目标周期标准数据验证数据(达成度)[4256]   */
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getDataType(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-数据类型编码不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getResultType(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-结果产生类型 不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getDataResult(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-数据值结果不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getPeriodId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-周期ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getCycleStartTime(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-周期开始时间不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getCycleEndTime(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-周期结束时间不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getCycleTypeCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-周期类型标识不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getIsNewData(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-是否最新数据不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getTableTypeCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-归属内容表类型编码不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getEntityId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-归属内容表主键ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getPersonLiableObjId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-填报评价责任人对象ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getBizRoleObjId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-填报评价责任人业务角色对象ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getBizRoleObjCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-填报评价责任人业务角色标识不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getPersonLiableTypeCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-填报评价责任人身份类型编码不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getBizRoleObjName(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-填报评价责任人业务角色对象名称不能为空", false);
        buildSingleEvaObjTarCycStaDataComRespDto_6 = buildSingleEvaObjTarCycStaDataCom(buildSingleEvaObjTarCycStaDataComReqDto_3);


//步骤5: D4-构造单条被评对象目标周期标准数据验证数据(公共) - buildSingleEvaObjTarCycStaDataCom
        BuildSingleEvaObjTarCycStaDataComRespDto buildSingleEvaObjTarCycStaDataComRespDto_8 = null;
        BuildSingleEvaObjTarCycStaDataComReqDto buildSingleEvaObjTarCycStaDataComReqDto_4 = new BuildSingleEvaObjTarCycStaDataComReqDto();
        buildSingleEvaObjTarCycStaDataComReqDto_4.setDataType("ACTUAL_FROM_LAST_TIME_RATIO");//sourceId:279524_1
        buildSingleEvaObjTarCycStaDataComReqDto_4.setResultType("SYSTEM_AUTO_COUNT");//sourceId:279534_1
        buildSingleEvaObjTarCycStaDataComReqDto_4.setIsNewData("TRUE");//sourceId:279535_1
        buildSingleEvaObjTarCycStaDataComReqDto_4.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:279525_1
        buildSingleEvaObjTarCycStaDataComReqDto_4.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:279527_1
        if (reqDto != null) {
            buildSingleEvaObjTarCycStaDataComReqDto_4.setDataResult(reqDto.getActualFromLastTimeRatio());//sourceId:279515_1
            buildSingleEvaObjTarCycStaDataComReqDto_4.setUnit(reqDto.getActualFromLastTimeRatioUnit());//sourceId:279518_1
            buildSingleEvaObjTarCycStaDataComReqDto_4.setPeriodId(reqDto.getCycleId());//sourceId:279519_1
            buildSingleEvaObjTarCycStaDataComReqDto_4.setCycleStartTime(reqDto.getCycleStartTime());//sourceId:279520_1
            buildSingleEvaObjTarCycStaDataComReqDto_4.setCycleEndTime(reqDto.getCycleEndTime());//sourceId:279521_1
            buildSingleEvaObjTarCycStaDataComReqDto_4.setCycleTypeCode(reqDto.getCycleTypeCode());//sourceId:279522_1
            buildSingleEvaObjTarCycStaDataComReqDto_4.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//sourceId:279523_1
            buildSingleEvaObjTarCycStaDataComReqDto_4.setEntityId(reqDto.getEvaObjTargetCycleId());//sourceId:279526_1
            buildSingleEvaObjTarCycStaDataComReqDto_4.setFromContentEntityId(reqDto.getCycleStageDataId());//sourceId:279528_1
            buildSingleEvaObjTarCycStaDataComReqDto_4.setBelongToContentTypeCode(reqDto.getTargetCycleContentTypeCode());//sourceId:301702_1
            buildSingleEvaObjTarCycStaDataComReqDto_4.setBelongToContentId(reqDto.getTargetCycleContentId());//sourceId:301703_1
            buildSingleEvaObjTarCycStaDataComReqDto_4.setPersonLiableObjId(reqDto.getPersonLiableObjId());//sourceId:279529_1
            buildSingleEvaObjTarCycStaDataComReqDto_4.setBizRoleObjId(reqDto.getBizRoleObjId());//sourceId:279530_1
            buildSingleEvaObjTarCycStaDataComReqDto_4.setBizRoleObjCode(reqDto.getBizRoleObjCode());//sourceId:279531_1
            buildSingleEvaObjTarCycStaDataComReqDto_4.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//sourceId:279532_1
            buildSingleEvaObjTarCycStaDataComReqDto_4.setBizRoleObjName(reqDto.getBizRoleObjName());//sourceId:279533_1
        }

        /*D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)[4256]   */
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getDataType(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-数据类型编码不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getResultType(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-结果产生类型 不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getDataResult(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-数据值结果不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getPeriodId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-周期ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getCycleStartTime(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-周期开始时间不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getCycleEndTime(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-周期结束时间不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getCycleTypeCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-周期类型标识不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getIsNewData(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-是否最新数据不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getTableTypeCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-归属内容表类型编码不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getEntityId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-归属内容表主键ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getPersonLiableObjId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-填报评价责任人对象ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getBizRoleObjId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-填报评价责任人业务角色对象ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getBizRoleObjCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-填报评价责任人业务角色标识不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getPersonLiableTypeCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-填报评价责任人身份类型编码不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getBizRoleObjName(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-填报评价责任人业务角色对象名称不能为空", false);
        buildSingleEvaObjTarCycStaDataComRespDto_8 = buildSingleEvaObjTarCycStaDataCom(buildSingleEvaObjTarCycStaDataComReqDto_4);


//步骤6: D4-构造单条被评对象目标周期标准数据验证数据(公共) - buildSingleEvaObjTarCycStaDataCom
        BuildSingleEvaObjTarCycStaDataComRespDto buildSingleEvaObjTarCycStaDataComRespDto_10 = null;
        BuildSingleEvaObjTarCycStaDataComReqDto buildSingleEvaObjTarCycStaDataComReqDto_5 = new BuildSingleEvaObjTarCycStaDataComReqDto();
        buildSingleEvaObjTarCycStaDataComReqDto_5.setDataType("REAL_TIME_SCORE");//sourceId:279546_1
        buildSingleEvaObjTarCycStaDataComReqDto_5.setResultType("SYSTEM_AUTO_COUNT");//sourceId:279556_1
        buildSingleEvaObjTarCycStaDataComReqDto_5.setIsNewData("TRUE");//sourceId:279557_1
        buildSingleEvaObjTarCycStaDataComReqDto_5.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:279547_1
        buildSingleEvaObjTarCycStaDataComReqDto_5.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:279549_1
        if (reqDto != null) {
            buildSingleEvaObjTarCycStaDataComReqDto_5.setDataResult(reqDto.getRealTimeScore());//sourceId:279537_1
            buildSingleEvaObjTarCycStaDataComReqDto_5.setUnit(reqDto.getRealTimeScoreUnit());//sourceId:279540_1
            buildSingleEvaObjTarCycStaDataComReqDto_5.setPeriodId(reqDto.getCycleId());//sourceId:279541_1
            buildSingleEvaObjTarCycStaDataComReqDto_5.setCycleStartTime(reqDto.getCycleStartTime());//sourceId:279542_1
            buildSingleEvaObjTarCycStaDataComReqDto_5.setCycleEndTime(reqDto.getCycleEndTime());//sourceId:279543_1
            buildSingleEvaObjTarCycStaDataComReqDto_5.setCycleTypeCode(reqDto.getCycleTypeCode());//sourceId:279544_1
            buildSingleEvaObjTarCycStaDataComReqDto_5.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//sourceId:279545_1
            buildSingleEvaObjTarCycStaDataComReqDto_5.setEntityId(reqDto.getEvaObjTargetCycleId());//sourceId:279548_1
            buildSingleEvaObjTarCycStaDataComReqDto_5.setFromContentEntityId(reqDto.getCycleStageDataId());//sourceId:279550_1
            buildSingleEvaObjTarCycStaDataComReqDto_5.setBelongToContentTypeCode(reqDto.getTargetCycleContentTypeCode());//sourceId:301704_1
            buildSingleEvaObjTarCycStaDataComReqDto_5.setBelongToContentId(reqDto.getTargetCycleContentId());//sourceId:301705_1
            buildSingleEvaObjTarCycStaDataComReqDto_5.setPersonLiableObjId(reqDto.getPersonLiableObjId());//sourceId:279551_1
            buildSingleEvaObjTarCycStaDataComReqDto_5.setBizRoleObjId(reqDto.getBizRoleObjId());//sourceId:279552_1
            buildSingleEvaObjTarCycStaDataComReqDto_5.setBizRoleObjCode(reqDto.getBizRoleObjCode());//sourceId:279553_1
            buildSingleEvaObjTarCycStaDataComReqDto_5.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//sourceId:279554_1
            buildSingleEvaObjTarCycStaDataComReqDto_5.setBizRoleObjName(reqDto.getBizRoleObjName());//sourceId:279555_1
        }

        /*D4-构造单条被评对象目标周期标准数据验证数据(实时得分)[4256]   */
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getDataType(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-数据类型编码不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getResultType(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-结果产生类型 不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getDataResult(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-数据值结果不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getPeriodId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-周期ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getCycleStartTime(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-周期开始时间不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getCycleEndTime(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-周期结束时间不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getCycleTypeCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-周期类型标识不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getIsNewData(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-是否最新数据不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getTableTypeCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-归属内容表类型编码不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getEntityId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-归属内容表主键ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getPersonLiableObjId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-填报评价责任人对象ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getBizRoleObjId(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-填报评价责任人业务角色对象ID不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getBizRoleObjCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-填报评价责任人业务角色标识不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getPersonLiableTypeCode(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-填报评价责任人身份类型编码不能为空", false);
        Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getBizRoleObjName(), "D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-填报评价责任人业务角色对象名称不能为空", false);
        buildSingleEvaObjTarCycStaDataComRespDto_10 = buildSingleEvaObjTarCycStaDataCom(buildSingleEvaObjTarCycStaDataComReqDto_5);


        BuildMultiEvaObjTarCycStaDataComRespDto retData = new BuildMultiEvaObjTarCycStaDataComRespDto();


        return retData;
    }

    /**
     * D4-删除单条被评对象目标周期标准数据(公共)[4379]
     * gen by moon at 11/25/2022, 4:55:06 PM
     */
    @Trace(operationName = "D4-删除单条被评对象目标周期标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public DeleteSingleEvaObjTarCycStaDataComRespDto deleteSingleEvaObjTarCycStaDataCom(DeleteSingleEvaObjTarCycStaDataComReqDto reqDto) {


        //步骤0: M4-查询单条被评对象目标周期标准数据列表 - querySingleEvaObjTarCycStaDataList
        List<OmsStandardDataResult> listOmsStandardDataResult = new ArrayList<>();
        QuerySingleEvaObjTarCycStaDataListReq querySingleEvaObjTarCycStaDataListReq = new QuerySingleEvaObjTarCycStaDataListReq();
        if (reqDto != null) {
            querySingleEvaObjTarCycStaDataListReq.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:305659_1
            querySingleEvaObjTarCycStaDataListReq.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:305660_1
        }

        /*M4-查询单条被评对象目标周期标准数据列表[4380]   */
        Assert.isNull(querySingleEvaObjTarCycStaDataListReq.getBelongToContentTypeCode(), "D4-删除单条被评对象目标周期标准数据(公共)-M4-查询单条被评对象目标周期标准数据列表-数据归属内容类型编码不能为空", false);
        Assert.isNull(querySingleEvaObjTarCycStaDataListReq.getBelongToContentId(), "D4-删除单条被评对象目标周期标准数据(公共)-M4-查询单条被评对象目标周期标准数据列表-数据归属内容ID不能为空", false);
        listOmsStandardDataResult = mOmsStandardDataResultService.querySingleEvaObjTarCycStaDataList(querySingleEvaObjTarCycStaDataListReq);


//步骤1: M4-批量删多条被评对象目标周期标准数据 - batchDeleteMultiEvaObjTarCycStaData
        boolean bOOLEAN;
        if (listOmsStandardDataResult != null && !CollectionUtil.isEmpty(listOmsStandardDataResult) && listOmsStandardDataResult.size() > 0) {
            List<String> listString = new ArrayList<>();
            listString = listOmsStandardDataResult.stream().map(item -> item.getDataResultId())
                    .collect(Collectors.toList());/*list-to-strings*///sourceId:305671_1

            /*M4-批量删多条被评对象目标周期标准数据[4374]   */

            bOOLEAN = mOmsStandardDataResultService.batchDeleteMultiEvaObjTarCycStaData(listString);


        }

        DeleteSingleEvaObjTarCycStaDataComRespDto retData = new DeleteSingleEvaObjTarCycStaDataComRespDto();


        return retData;
    }

    /**
     * D4-批量删多条被评对象目标周期标准数据(公共)[4372]
     * gen by moon at 11/25/2022, 4:55:16 PM
     */
    @Trace(operationName = "D4-批量删多条被评对象目标周期标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchDeleteMultiEvaObjTarCycStaDataComRespDto batchDeleteMultiEvaObjTarCycStaDataCom(BatchDeleteMultiEvaObjTarCycStaDataComReqDto reqDto) {


        //步骤0: M4-查询多条被评对象目标周期标准数据列表 - queryMultiEvaObjTarCycStaDataList
        List<OmsStandardDataResult> listOmsStandardDataResult = new ArrayList<>();
        QueryMultiEvaObjTarCycStaDataListReq queryMultiEvaObjTarCycStaDataListReq = new QueryMultiEvaObjTarCycStaDataListReq();
        if (reqDto != null) {
            queryMultiEvaObjTarCycStaDataListReq.setMultiEvaObjTarCycStaDataList(reqDto.getMultiEvaObjTarCycStaDataList());//list-field-assign//sourceId:304372_1
            queryMultiEvaObjTarCycStaDataListReq.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:304373_1
        }

        /*M4-查询多条被评对象目标周期标准数据列表[4373]   */

        listOmsStandardDataResult = mOmsStandardDataResultService.queryMultiEvaObjTarCycStaDataList(queryMultiEvaObjTarCycStaDataListReq);


//步骤1: M4-批量删多条被评对象目标周期标准数据 - batchDeleteMultiEvaObjTarCycStaData
        boolean bOOLEAN;
        if (listOmsStandardDataResult != null && !CollectionUtil.isEmpty(listOmsStandardDataResult) && listOmsStandardDataResult.size() > 0) {
            List<String> listString = new ArrayList<>();
            listString = listOmsStandardDataResult.stream().map(item -> item.getDataResultId())
                    .collect(Collectors.toList());/*list-to-strings*///sourceId:304376_1

            /*M4-批量删多条被评对象目标周期标准数据[4374]   */

            bOOLEAN = mOmsStandardDataResultService.batchDeleteMultiEvaObjTarCycStaData(listString);


        }

        BatchDeleteMultiEvaObjTarCycStaDataComRespDto retData = new BatchDeleteMultiEvaObjTarCycStaDataComRespDto();


        return retData;
    }

    /**
     * D4-1-01一键删除多条被评对象目标周期标准数据验证数据(公共)[4447]
     * gen by moon at 6/22/2024, 9:48:23 AM
     */
    @Trace(operationName = "D4-1-01一键删除多条被评对象目标周期标准数据验证数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AutoDeleteMultiEvaObjTarCycStaDataComRespDto autoDeleteMultiEvaObjTarCycStaDataCom(AutoDeleteMultiEvaObjTarCycStaDataComReqDto reqDto) {


        //步骤0: M4-1-01查询被评对象目标周期标准数据列表 - queryEvaObjTarCycStaDataList
        List<OmsStandardDataResult> listOmsStandardDataResult = new ArrayList<>();
        QueryEvaObjTarCycStaDataListReq queryEvaObjTarCycStaDataListReq = new QueryEvaObjTarCycStaDataListReq();
        if (reqDto != null) {
            queryEvaObjTarCycStaDataListReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:311607_1
            queryEvaObjTarCycStaDataListReq.setFromContentEntityId(reqDto.getFromContentEntityId());//SimpleFieldAssign//sourceId:1886373_1
            queryEvaObjTarCycStaDataListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1032511_1
        }

        /*M4-1-01查询被评对象目标周期标准数据列表[4460]   */

        listOmsStandardDataResult = mOmsStandardDataResultService.queryEvaObjTarCycStaDataList(queryEvaObjTarCycStaDataListReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤1: M4-1-01一键删除被评对象目标周期标准数据验证数据 - autoDeleteEvaObjTarCycStaData
        boolean bOOLEAN;
        if (listOmsStandardDataResult != null && !CollectionUtil.isEmpty(listOmsStandardDataResult) && listOmsStandardDataResult.size() > 0) {
            List<String> listString = new ArrayList<>();
            if (listOmsStandardDataResult != null && !CollectionUtil.isEmpty(listOmsStandardDataResult) && listOmsStandardDataResult != null && !CollectionUtil.isEmpty(listOmsStandardDataResult)) {
                listString = listOmsStandardDataResult.stream().map(item -> item.getDataResultId())
                        .collect(Collectors.toList());/*list-to-strings*///sourceId:311610_1
            }

            /*M4-1-01一键删除被评对象目标周期标准数据验证数据[4425]   */

            bOOLEAN = mOmsStandardDataResultService.autoDeleteEvaObjTarCycStaData(listString)/*vcase invoke 本地 method 方法调用;*/;


        }

        AutoDeleteMultiEvaObjTarCycStaDataComRespDto retData = new AutoDeleteMultiEvaObjTarCycStaDataComRespDto();


        return retData;
    }

    /**
     * D4-1-01修改单条被评对象目标周期标准数据[4535]
     * gen by moon at 9/10/2022, 5:28:55 PM
     */
    @Trace(operationName = "D4-1-01修改单条被评对象目标周期标准数据")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public UpdateSingleEvaObjTarCycStaDataRespDto updateSingleEvaObjTarCycStaData(UpdateSingleEvaObjTarCycStaDataReqDto reqDto) {


        //步骤0: M4-1-01查询单条被评对象目标周期标准数据详情 - querySingleEvaObjTarCycStaDataDetail
        OmsStandardDataResult omsStandardDataResult = null;
        QuerySingleEvaObjTarCycStaDataDetailReq querySingleEvaObjTarCycStaDataDetailReq = new QuerySingleEvaObjTarCycStaDataDetailReq();
        querySingleEvaObjTarCycStaDataDetailReq.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:320816_1
        querySingleEvaObjTarCycStaDataDetailReq.setDataType("ACTUAL_VALUE");//sourceId:320820_1
        if (reqDto != null) {
            querySingleEvaObjTarCycStaDataDetailReq.setPeriodId(reqDto.getPeriodId());//sourceId:320815_1
            querySingleEvaObjTarCycStaDataDetailReq.setEntityId(reqDto.getEntityId());//sourceId:320817_1
        }

        /*M4-1-01查实际值[4536]   */
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq.getPeriodId(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查实际值-周期ID不能为空", false);
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq.getTableTypeCode(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查实际值-归属内容表类型编码不能为空", false);
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq.getEntityId(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查实际值-归属内容表主键ID不能为空", false);
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq.getDataType(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查实际值-数据类型编码不能为空", false);
        omsStandardDataResult = mOmsStandardDataResultService.querySingleEvaObjTarCycStaDataDetail(querySingleEvaObjTarCycStaDataDetailReq);


//步骤1: M4-1-01修改单条被评对象目标周期标准数据 - updateSingleEvaObjTarCycStaData
        boolean bOOLEAN;
        if (omsStandardDataResult != null) {
            OmsStandardDataResult omsStandardDataResult_2 = new OmsStandardDataResult();
            if (omsStandardDataResult != null) {
                omsStandardDataResult_2.setDataResultId(omsStandardDataResult.getDataResultId());//sourceId:320835_1
            }
            if (reqDto != null) {
                omsStandardDataResult_2.setDataResult(reqDto.getActualValue());//sourceId:320836_1
                omsStandardDataResult_2.setParentDataResult(reqDto.getParentActualValue());//sourceId:320837_1
                omsStandardDataResult_2.setUnit(reqDto.getUnit());//sourceId:320838_1
                omsStandardDataResult_2.setIsNewData(reqDto.getIsNewData());//sourceId:320839_1
                omsStandardDataResult_2.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:320840_1
                omsStandardDataResult_2.setIsArchive(reqDto.getIsArchive());//sourceId:320841_1
            }

            /*M4-1-01修改实际值[4537]   */
            Assert.isNull(omsStandardDataResult_2.getDataResultId(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01修改实际值-数据结果ID 不能为空", false);
            bOOLEAN = mOmsStandardDataResultService.updateSingleEvaObjTarCycStaData(omsStandardDataResult_2);


        }

//步骤2: M4-1-01查询单条被评对象目标周期标准数据详情 - querySingleEvaObjTarCycStaDataDetail
        OmsStandardDataResult omsStandardDataResult_3 = null;
        QuerySingleEvaObjTarCycStaDataDetailReq querySingleEvaObjTarCycStaDataDetailReq_1 = new QuerySingleEvaObjTarCycStaDataDetailReq();
        querySingleEvaObjTarCycStaDataDetailReq_1.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:320852_1
        querySingleEvaObjTarCycStaDataDetailReq_1.setDataType("PROGRESS_VALUE");//sourceId:320855_1
        if (reqDto != null) {
            querySingleEvaObjTarCycStaDataDetailReq_1.setPeriodId(reqDto.getPeriodId());//sourceId:320851_1
            querySingleEvaObjTarCycStaDataDetailReq_1.setEntityId(reqDto.getEntityId());//sourceId:320853_1
        }

        /*M4-1-01查进度值[4536]   */
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_1.getPeriodId(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查进度值-周期ID不能为空", false);
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_1.getTableTypeCode(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查进度值-归属内容表类型编码不能为空", false);
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_1.getEntityId(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查进度值-归属内容表主键ID不能为空", false);
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_1.getDataType(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查进度值-数据类型编码不能为空", false);
        omsStandardDataResult_3 = mOmsStandardDataResultService.querySingleEvaObjTarCycStaDataDetail(querySingleEvaObjTarCycStaDataDetailReq_1);


//步骤3: M4-1-01修改单条被评对象目标周期标准数据 - updateSingleEvaObjTarCycStaData
        boolean bOOLEAN_1;
        if (omsStandardDataResult_3 != null) {
            OmsStandardDataResult omsStandardDataResult_5 = new OmsStandardDataResult();
            if (omsStandardDataResult_3 != null) {
                omsStandardDataResult_5.setDataResultId(omsStandardDataResult_3.getDataResultId());//sourceId:320876_1
            }
            if (reqDto != null) {
                omsStandardDataResult_5.setDataResult(reqDto.getProgressValue());//sourceId:320877_1
                omsStandardDataResult_5.setParentDataResult(reqDto.getParentProgressValue());//sourceId:320878_1
                omsStandardDataResult_5.setUnit(reqDto.getUnit());//sourceId:320879_1
                omsStandardDataResult_5.setIsNewData(reqDto.getIsNewData());//sourceId:320880_1
                omsStandardDataResult_5.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:320881_1
                omsStandardDataResult_5.setIsArchive(reqDto.getIsArchive());//sourceId:320882_1
            }

            /*M4-1-01修改进度值[4537]   */
            Assert.isNull(omsStandardDataResult_5.getDataResultId(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01修改进度值-数据结果ID 不能为空", false);
            bOOLEAN_1 = mOmsStandardDataResultService.updateSingleEvaObjTarCycStaData(omsStandardDataResult_5);


        }

//步骤4: M4-1-01查询单条被评对象目标周期标准数据详情 - querySingleEvaObjTarCycStaDataDetail
        OmsStandardDataResult omsStandardDataResult_6 = null;
        QuerySingleEvaObjTarCycStaDataDetailReq querySingleEvaObjTarCycStaDataDetailReq_2 = new QuerySingleEvaObjTarCycStaDataDetailReq();
        querySingleEvaObjTarCycStaDataDetailReq_2.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:320857_1
        querySingleEvaObjTarCycStaDataDetailReq_2.setDataType("REACH");//sourceId:320860_1
        if (reqDto != null) {
            querySingleEvaObjTarCycStaDataDetailReq_2.setPeriodId(reqDto.getPeriodId());//sourceId:320856_1
            querySingleEvaObjTarCycStaDataDetailReq_2.setEntityId(reqDto.getEntityId());//sourceId:320858_1
        }

        /*M4-1-01查达成度[4536]   */
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_2.getPeriodId(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查达成度-周期ID不能为空", false);
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_2.getTableTypeCode(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查达成度-归属内容表类型编码不能为空", false);
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_2.getEntityId(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查达成度-归属内容表主键ID不能为空", false);
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_2.getDataType(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查达成度-数据类型编码不能为空", false);
        omsStandardDataResult_6 = mOmsStandardDataResultService.querySingleEvaObjTarCycStaDataDetail(querySingleEvaObjTarCycStaDataDetailReq_2);


//步骤5: M4-1-01修改单条被评对象目标周期标准数据 - updateSingleEvaObjTarCycStaData
        boolean bOOLEAN_2;
        if (omsStandardDataResult_6 != null) {
            OmsStandardDataResult omsStandardDataResult_8 = new OmsStandardDataResult();
            if (omsStandardDataResult_6 != null) {
                omsStandardDataResult_8.setDataResultId(omsStandardDataResult_6.getDataResultId());//sourceId:320940_1
            }
            if (reqDto != null) {
                omsStandardDataResult_8.setDataResult(reqDto.getReach());//sourceId:320941_1
                omsStandardDataResult_8.setParentDataResult(reqDto.getParentReach());//sourceId:320942_1
                omsStandardDataResult_8.setUnit(reqDto.getUnit());//sourceId:320943_1
                omsStandardDataResult_8.setIsNewData(reqDto.getIsNewData());//sourceId:320944_1
                omsStandardDataResult_8.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:320945_1
                omsStandardDataResult_8.setIsArchive(reqDto.getIsArchive());//sourceId:320946_1
            }

            /*M4-1-01修改达成度[4537]   */
            Assert.isNull(omsStandardDataResult_8.getDataResultId(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01修改达成度-数据结果ID 不能为空", false);
            bOOLEAN_2 = mOmsStandardDataResultService.updateSingleEvaObjTarCycStaData(omsStandardDataResult_8);


        }

//步骤6: M4-1-01查询单条被评对象目标周期标准数据详情 - querySingleEvaObjTarCycStaDataDetail
        OmsStandardDataResult omsStandardDataResult_9 = null;
        QuerySingleEvaObjTarCycStaDataDetailReq querySingleEvaObjTarCycStaDataDetailReq_3 = new QuerySingleEvaObjTarCycStaDataDetailReq();
        querySingleEvaObjTarCycStaDataDetailReq_3.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:320862_1
        querySingleEvaObjTarCycStaDataDetailReq_3.setDataType("REAL_TIME_SCORE");//sourceId:320865_1
        if (reqDto != null) {
            querySingleEvaObjTarCycStaDataDetailReq_3.setPeriodId(reqDto.getPeriodId());//sourceId:320861_1
            querySingleEvaObjTarCycStaDataDetailReq_3.setEntityId(reqDto.getEntityId());//sourceId:320863_1
        }

        /*M4-1-01查实时得分[4536]   */
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_3.getPeriodId(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查实时得分-周期ID不能为空", false);
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_3.getTableTypeCode(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查实时得分-归属内容表类型编码不能为空", false);
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_3.getEntityId(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查实时得分-归属内容表主键ID不能为空", false);
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_3.getDataType(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查实时得分-数据类型编码不能为空", false);
        omsStandardDataResult_9 = mOmsStandardDataResultService.querySingleEvaObjTarCycStaDataDetail(querySingleEvaObjTarCycStaDataDetailReq_3);


//步骤7: M4-1-01修改单条被评对象目标周期标准数据 - updateSingleEvaObjTarCycStaData
        boolean bOOLEAN_3;
        if (omsStandardDataResult_9 != null) {
            OmsStandardDataResult omsStandardDataResult_11 = new OmsStandardDataResult();
            if (omsStandardDataResult_9 != null) {
                omsStandardDataResult_11.setDataResultId(omsStandardDataResult_9.getDataResultId());//sourceId:320949_1
            }
            if (reqDto != null) {
                omsStandardDataResult_11.setDataResult(reqDto.getRealTimeScore());//sourceId:320950_1
                omsStandardDataResult_11.setParentDataResult(reqDto.getParentRealTimeScore());//sourceId:320951_1
                omsStandardDataResult_11.setUnit(reqDto.getUnit());//sourceId:320952_1
                omsStandardDataResult_11.setIsNewData(reqDto.getIsNewData());//sourceId:320953_1
                omsStandardDataResult_11.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:320954_1
                omsStandardDataResult_11.setIsArchive(reqDto.getIsArchive());//sourceId:320955_1
            }

            /*M4-1-01修改实时得分[4537]   */
            Assert.isNull(omsStandardDataResult_11.getDataResultId(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01修改实时得分-数据结果ID 不能为空", false);
            bOOLEAN_3 = mOmsStandardDataResultService.updateSingleEvaObjTarCycStaData(omsStandardDataResult_11);


        }

//步骤8: M4-1-01查询单条被评对象目标周期标准数据详情 - querySingleEvaObjTarCycStaDataDetail
        OmsStandardDataResult omsStandardDataResult_12 = null;
        QuerySingleEvaObjTarCycStaDataDetailReq querySingleEvaObjTarCycStaDataDetailReq_4 = new QuerySingleEvaObjTarCycStaDataDetailReq();
        querySingleEvaObjTarCycStaDataDetailReq_4.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:320867_1
        querySingleEvaObjTarCycStaDataDetailReq_4.setDataType("PROGRESS_FROM_LAST_RATIO");//sourceId:320870_1
        if (reqDto != null) {
            querySingleEvaObjTarCycStaDataDetailReq_4.setPeriodId(reqDto.getPeriodId());//sourceId:320866_1
            querySingleEvaObjTarCycStaDataDetailReq_4.setEntityId(reqDto.getEntityId());//sourceId:320868_1
        }

        /*M4-1-01查进度较上次增降幅[4536]   */
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_4.getPeriodId(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查进度较上次增降幅-周期ID不能为空", false);
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_4.getTableTypeCode(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查进度较上次增降幅-归属内容表类型编码不能为空", false);
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_4.getEntityId(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查进度较上次增降幅-归属内容表主键ID不能为空", false);
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_4.getDataType(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查进度较上次增降幅-数据类型编码不能为空", false);
        omsStandardDataResult_12 = mOmsStandardDataResultService.querySingleEvaObjTarCycStaDataDetail(querySingleEvaObjTarCycStaDataDetailReq_4);


//步骤9: M4-1-01修改单条被评对象目标周期标准数据 - updateSingleEvaObjTarCycStaData
        boolean bOOLEAN_4;
        if (omsStandardDataResult_12 != null) {
            OmsStandardDataResult omsStandardDataResult_14 = new OmsStandardDataResult();
            if (omsStandardDataResult_12 != null) {
                omsStandardDataResult_14.setDataResultId(omsStandardDataResult_12.getDataResultId());//sourceId:320968_1
            }
            if (reqDto != null) {
                omsStandardDataResult_14.setDataResult(reqDto.getProgressFromLastRatio());//sourceId:320969_1
                omsStandardDataResult_14.setParentDataResult(reqDto.getParentProgressFromLastRatio());//sourceId:320970_1
                omsStandardDataResult_14.setUnit(reqDto.getUnit());//sourceId:320971_1
                omsStandardDataResult_14.setIsNewData(reqDto.getIsNewData());//sourceId:320972_1
                omsStandardDataResult_14.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:320973_1
                omsStandardDataResult_14.setIsArchive(reqDto.getIsArchive());//sourceId:320974_1
            }

            /*M4-1-01修改进度较上次增降幅[4537]   */
            Assert.isNull(omsStandardDataResult_14.getDataResultId(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01修改进度较上次增降幅-数据结果ID 不能为空", false);
            bOOLEAN_4 = mOmsStandardDataResultService.updateSingleEvaObjTarCycStaData(omsStandardDataResult_14);


        }

//步骤10: M4-1-01查询单条被评对象目标周期标准数据详情 - querySingleEvaObjTarCycStaDataDetail
        OmsStandardDataResult omsStandardDataResult_15 = null;
        QuerySingleEvaObjTarCycStaDataDetailReq querySingleEvaObjTarCycStaDataDetailReq_5 = new QuerySingleEvaObjTarCycStaDataDetailReq();
        querySingleEvaObjTarCycStaDataDetailReq_5.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:320872_1
        querySingleEvaObjTarCycStaDataDetailReq_5.setDataType("ACTUAL_FROM_LAST_TIME_RATIO");//sourceId:320875_1
        if (reqDto != null) {
            querySingleEvaObjTarCycStaDataDetailReq_5.setPeriodId(reqDto.getPeriodId());//sourceId:320871_1
            querySingleEvaObjTarCycStaDataDetailReq_5.setEntityId(reqDto.getEntityId());//sourceId:320873_1
        }

        /*M4-1-01查达成度较上次增降幅[4536]   */
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_5.getPeriodId(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查达成度较上次增降幅-周期ID不能为空", false);
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_5.getTableTypeCode(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查达成度较上次增降幅-归属内容表类型编码不能为空", false);
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_5.getEntityId(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查达成度较上次增降幅-归属内容表主键ID不能为空", false);
        Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_5.getDataType(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查达成度较上次增降幅-数据类型编码不能为空", false);
        omsStandardDataResult_15 = mOmsStandardDataResultService.querySingleEvaObjTarCycStaDataDetail(querySingleEvaObjTarCycStaDataDetailReq_5);


//步骤11: M4-1-01修改单条被评对象目标周期标准数据 - updateSingleEvaObjTarCycStaData
        boolean bOOLEAN_5;
        if (omsStandardDataResult_15 != null) {
            OmsStandardDataResult omsStandardDataResult_17 = new OmsStandardDataResult();
            if (omsStandardDataResult_15 != null) {
                omsStandardDataResult_17.setDataResultId(omsStandardDataResult_15.getDataResultId());//sourceId:320960_1
            }
            if (reqDto != null) {
                omsStandardDataResult_17.setDataResult(reqDto.getActualFromLastTimeRatio());//sourceId:320961_1
                omsStandardDataResult_17.setParentDataResult(reqDto.getParentActualFromLastTimeRatio());//sourceId:320962_1
                omsStandardDataResult_17.setUnit(reqDto.getUnit());//sourceId:320963_1
                omsStandardDataResult_17.setIsNewData(reqDto.getIsNewData());//sourceId:320964_1
                omsStandardDataResult_17.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:320965_1
                omsStandardDataResult_17.setIsArchive(reqDto.getIsArchive());//sourceId:320966_1
            }

            /*M4-1-01修改达成度较上次增降幅[4537]   */
            Assert.isNull(omsStandardDataResult_17.getDataResultId(), "D4-1-01修改单条被评对象目标周期标准数据-M4-1-01修改达成度较上次增降幅-数据结果ID 不能为空", false);
            bOOLEAN_5 = mOmsStandardDataResultService.updateSingleEvaObjTarCycStaData(omsStandardDataResult_17);


        }

        UpdateSingleEvaObjTarCycStaDataRespDto retData = new UpdateSingleEvaObjTarCycStaDataRespDto();


        return retData;
    }

    /**
     * D4执行刷模板标准数据（运维）[9676]
     * gen by moon at 5/30/2024, 4:13:57 PM
     */
    @Trace(operationName = "D4执行刷模板标准数据（运维）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementBrushTempStandardDataRespDto implementBrushTempStandardData(ImplementBrushTempStandardDataReqDto reqDto) {


        //virtualUsage M4查询评价模板下标准数据列表（用于循环发牌使用）  69331
        List<OmsStandardDataResult> listOmsStandardDataResult = new ArrayList<>();
        QuerySingleEvaObjTarCycStaDataListReq querySingleEvaObjTarCycStaDataListReq = new QuerySingleEvaObjTarCycStaDataListReq();
        if (reqDto != null) {
            querySingleEvaObjTarCycStaDataListReq.setResultType(reqDto.getResultType());//SimpleFieldAssign//sourceId:1825343_1_69331
            querySingleEvaObjTarCycStaDataListReq.setDataUsageSceneCode(reqDto.getDataUsageSceneCode());//SimpleFieldAssign//sourceId:1825344_1_69331
            querySingleEvaObjTarCycStaDataListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1825347_1_69331
        }

        /*M4查询评价模板下标准数据列表（用于循环发牌使用）[4380]   */
        Assert.isNull(querySingleEvaObjTarCycStaDataListReq.getDataUsageSceneCode(), "D4执行刷模板标准数据（运维）-M4查询评价模板下标准数据列表（用于循环发牌使用）-数据业务场景不能为空", false);
        Assert.isNull(querySingleEvaObjTarCycStaDataListReq.getThemeContentId(), "D4执行刷模板标准数据（运维）-M4查询评价模板下标准数据列表（用于循环发牌使用）-主题内容ID不能为空", false);
        listOmsStandardDataResult = mOmsStandardDataResultService.querySingleEvaObjTarCycStaDataList(querySingleEvaObjTarCycStaDataListReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((listOmsStandardDataResult != null && listOmsStandardDataResult != null && listOmsStandardDataResult.size() > 0)) {
            //if(M4查询评价模板下标准数据列表（用于循环发牌使用）.多条被评对象目标周期标准数据列表数据集条数 大于 0)  69332

//ModelCode: circulationCollections
            for (OmsStandardDataResult circulationCollectionsRes : listOmsStandardDataResult) {

                ObtainTargetBelongCycleComRespDto obtainTargetBelongCycleComRespDto = null;
                ObtainTargetBelongCycleComReqDto obtainTargetBelongCycleComReqDto = new ObtainTargetBelongCycleComReqDto();
                obtainTargetBelongCycleComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1825362_1_69335
                if (reqDto != null) {
                    obtainTargetBelongCycleComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1825456_1_69335
                    obtainTargetBelongCycleComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1825455_1_69335
                    obtainTargetBelongCycleComReqDto.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1825453_1_69335
                }
                if (circulationCollectionsRes != null) {
                    obtainTargetBelongCycleComReqDto.setCycleId(circulationCollectionsRes.getPeriodId());//SimpleFieldAssign//sourceId:1825452_1_69335
                    obtainTargetBelongCycleComReqDto.setParentSubMidCycleType(circulationCollectionsRes.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1825506_1_69335
                    obtainTargetBelongCycleComReqDto.setEntityId(circulationCollectionsRes.getEntityId());//SimpleFieldAssign//sourceId:1825483_1_69335
                }

                /*D3标准数据对应的目标归属周期（用于修正当前标准数据使用）[8739]   */
                Assert.isNull(obtainTargetBelongCycleComReqDto.getEvaObjEntityId(), "D4执行刷模板标准数据（运维）-D3标准数据对应的目标归属周期（用于修正当前标准数据使用）-主树被评对象内容表主键ID不能为空", false);
                Assert.isNull(obtainTargetBelongCycleComReqDto.getEvaObjTypeCode(), "D4执行刷模板标准数据（运维）-D3标准数据对应的目标归属周期（用于修正当前标准数据使用）-主树被评对象类型编码不能为空", false);
                Assert.isNull(obtainTargetBelongCycleComReqDto.getCycleId(), "D4执行刷模板标准数据（运维）-D3标准数据对应的目标归属周期（用于修正当前标准数据使用）-归属周期ID不能为空", false);
                Assert.isNull(obtainTargetBelongCycleComReqDto.getEntityId(), "D4执行刷模板标准数据（运维）-D3标准数据对应的目标归属周期（用于修正当前标准数据使用）-归属内容表主键ID不能为空", false);
                Assert.isNull(obtainTargetBelongCycleComReqDto.getEvaluationTemplateId(), "D4执行刷模板标准数据（运维）-D3标准数据对应的目标归属周期（用于修正当前标准数据使用）-冗余评价模板ID不能为空", false);
                Assert.isNull(obtainTargetBelongCycleComReqDto.getSpaceId(), "D4执行刷模板标准数据（运维）-D3标准数据对应的目标归属周期（用于修正当前标准数据使用）-创建于空间ID不能为空", false);
                obtainTargetBelongCycleComRespDto = fwAppTargetCalcClient.obtainTargetBelongCycleCom(obtainTargetBelongCycleComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                PreparationPreviousStandardDataResultComRespDto preparationPreviousStandardDataResultComRespDto = null;
                if (obtainTargetBelongCycleComRespDto != null) {
                    PreparationPreviousStandardDataResultComReqDto preparationPreviousStandardDataResultComReqDto = new PreparationPreviousStandardDataResultComReqDto();
                    if (circulationCollectionsRes != null) {
                        preparationPreviousStandardDataResultComReqDto.setDataType(circulationCollectionsRes.getDataType());//SimpleFieldAssign//sourceId:1825508_1_69338
                        preparationPreviousStandardDataResultComReqDto.setAccountId(circulationCollectionsRes.getAccountId());//SimpleFieldAssign//sourceId:1825629_1_69338
                        preparationPreviousStandardDataResultComReqDto.setExtendedField5(circulationCollectionsRes.getExtendedField5());//SimpleFieldAssign//sourceId:1825563_1_69338
                    }
                    if (obtainTargetBelongCycleComRespDto != null) {
                        preparationPreviousStandardDataResultComReqDto.setCycleId(obtainTargetBelongCycleComRespDto.getPreviousCycleId());//SimpleFieldAssign//sourceId:1825507_1_69338
                        preparationPreviousStandardDataResultComReqDto.setEntityId(obtainTargetBelongCycleComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1825512_1_69338
                        preparationPreviousStandardDataResultComReqDto.setBizRoleObjCode(obtainTargetBelongCycleComRespDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1825511_1_69338
                        preparationPreviousStandardDataResultComReqDto.setBelongToPersonalIdentityId(obtainTargetBelongCycleComRespDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1825514_1_69338
                        preparationPreviousStandardDataResultComReqDto.setExtendedField1(obtainTargetBelongCycleComRespDto.getCategoryTableTypeCode());//SimpleFieldAssign//sourceId:1825515_1_69338
                        preparationPreviousStandardDataResultComReqDto.setExtendedField2(obtainTargetBelongCycleComRespDto.getOneLevelCategoryId());//SimpleFieldAssign//sourceId:1825547_1_69338
                        preparationPreviousStandardDataResultComReqDto.setExtendedField3(obtainTargetBelongCycleComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1825516_1_69338
                        preparationPreviousStandardDataResultComReqDto.setExtendedField4(obtainTargetBelongCycleComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1825548_1_69338
                    }
                    if (reqDto != null) {
                        preparationPreviousStandardDataResultComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1825517_1_69338
                    }

                    /*D4准备上一更新周期标准数据结果(公共)[8542]   */
                    Assert.isNull(preparationPreviousStandardDataResultComReqDto.getDataType(), "D4执行刷模板标准数据（运维）-D4准备上一更新周期标准数据结果(公共)-数据点类型不能为空", false);
//Assert.isNull(preparationPreviousStandardDataResultComReqDto.getEntityId(),"D4执行刷模板标准数据（运维）-D4准备上一更新周期标准数据结果(公共)-归属内容表主键ID不能为空",false);
                    Assert.isNull(preparationPreviousStandardDataResultComReqDto.getThemeContentId(), "D4执行刷模板标准数据（运维）-D4准备上一更新周期标准数据结果(公共)-主题内容ID不能为空", false);
                    preparationPreviousStandardDataResultComRespDto = standardDataService.preparationPreviousStandardDataResultCom(preparationPreviousStandardDataResultComReqDto)/*vcase invoke isSameApp*/;


                }
                CalculateDataPointIncDecMeasureAndAmplitudeComRespDto calculateDataPointIncDecMeasureAndAmplitudeComRespDto = null;
                if (preparationPreviousStandardDataResultComRespDto != null) {
                    CalculateDataPointIncDecMeasureAndAmplitudeComReqDto calculateDataPointIncDecMeasureAndAmplitudeComReqDto = new CalculateDataPointIncDecMeasureAndAmplitudeComReqDto();
                    if (preparationPreviousStandardDataResultComRespDto != null) {
                        calculateDataPointIncDecMeasureAndAmplitudeComReqDto.setParentDataResult(preparationPreviousStandardDataResultComRespDto.getDataResultId() != null ? Double.valueOf(preparationPreviousStandardDataResultComRespDto.getDataResultId()) : null);//SimpleFieldAssign//sourceId:1825555_1_69339
                    }
                    if (circulationCollectionsRes != null) {
                        calculateDataPointIncDecMeasureAndAmplitudeComReqDto.setDataResult(circulationCollectionsRes.getDataResult());//SimpleFieldAssign//sourceId:1825556_1_69339
                    }

                    /*D4计算数据点增降量与增降幅(公共)[8713]   */
                    Assert.isNull(calculateDataPointIncDecMeasureAndAmplitudeComReqDto.getDataResult(), "D4执行刷模板标准数据（运维）-D4计算数据点增降量与增降幅(公共)-数据值结果不能为空", false);
                    calculateDataPointIncDecMeasureAndAmplitudeComRespDto = targetCalcService.calculateDataPointIncDecMeasureAndAmplitudeCom(calculateDataPointIncDecMeasureAndAmplitudeComReqDto)/*vcase invoke isSameApp*/;


                }
                PreparationPreviousStandardDataResultComRespDto preparationPreviousStandardDataResultComRespDto_2 = null;
                if (obtainTargetBelongCycleComRespDto != null) {
                    PreparationPreviousStandardDataResultComReqDto preparationPreviousStandardDataResultComReqDto_1 = new PreparationPreviousStandardDataResultComReqDto();
                    if (circulationCollectionsRes != null) {
                        preparationPreviousStandardDataResultComReqDto_1.setDataType(circulationCollectionsRes.getDataType());//SimpleFieldAssign//sourceId:1825508_1_69340
                        preparationPreviousStandardDataResultComReqDto_1.setEntityId(circulationCollectionsRes.getEntityId());//SimpleFieldAssign//sourceId:1825512_1_69340
                        preparationPreviousStandardDataResultComReqDto_1.setBelongToPersonalIdentityId(circulationCollectionsRes.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1825514_1_69340
                        preparationPreviousStandardDataResultComReqDto_1.setAccountId(circulationCollectionsRes.getAccountId());//SimpleFieldAssign//sourceId:1825629_1_69340
                        preparationPreviousStandardDataResultComReqDto_1.setExtendedField5(circulationCollectionsRes.getExtendedField5());//SimpleFieldAssign//sourceId:1825563_1_69340
                    }
                    if (obtainTargetBelongCycleComRespDto != null) {
                        preparationPreviousStandardDataResultComReqDto_1.setCycleId(obtainTargetBelongCycleComRespDto.getPreviousCycleId());//SimpleFieldAssign//sourceId:1825507_1_69340
                        preparationPreviousStandardDataResultComReqDto_1.setBizRoleObjCode(obtainTargetBelongCycleComRespDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1825511_1_69340
                        preparationPreviousStandardDataResultComReqDto_1.setExtendedField1(obtainTargetBelongCycleComRespDto.getCategoryTableTypeCode());//SimpleFieldAssign//sourceId:1825515_1_69340
                        preparationPreviousStandardDataResultComReqDto_1.setExtendedField2(obtainTargetBelongCycleComRespDto.getOneLevelCategoryId());//SimpleFieldAssign//sourceId:1825547_1_69340
                        preparationPreviousStandardDataResultComReqDto_1.setExtendedField3(obtainTargetBelongCycleComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1825516_1_69340
                        preparationPreviousStandardDataResultComReqDto_1.setExtendedField4(obtainTargetBelongCycleComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1825548_1_69340
                    }
                    if (reqDto != null) {
                        preparationPreviousStandardDataResultComReqDto_1.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1825517_1_69340
                    }

                    /*D4准备上一更新周期标准数据结果(公共)[8542]   */
                    Assert.isNull(preparationPreviousStandardDataResultComReqDto_1.getDataType(), "D4执行刷模板标准数据（运维）-D4准备上一更新周期标准数据结果(公共)-数据点类型不能为空", false);
//Assert.isNull(preparationPreviousStandardDataResultComReqDto_1.getEntityId(),"D4执行刷模板标准数据（运维）-D4准备上一更新周期标准数据结果(公共)-归属内容表主键ID不能为空",false);
                    Assert.isNull(preparationPreviousStandardDataResultComReqDto_1.getThemeContentId(), "D4执行刷模板标准数据（运维）-D4准备上一更新周期标准数据结果(公共)-主题内容ID不能为空", false);
                    preparationPreviousStandardDataResultComRespDto_2 = standardDataService.preparationPreviousStandardDataResultCom(preparationPreviousStandardDataResultComReqDto_1)/*vcase invoke isSameApp*/;


                }
                CalculateDataPointIncDecMeasureAndAmplitudeComRespDto calculateDataPointIncDecMeasureAndAmplitudeComRespDto_2 = null;
                if (preparationPreviousStandardDataResultComRespDto_2 != null) {
                    CalculateDataPointIncDecMeasureAndAmplitudeComReqDto calculateDataPointIncDecMeasureAndAmplitudeComReqDto_1 = new CalculateDataPointIncDecMeasureAndAmplitudeComReqDto();
                    if (preparationPreviousStandardDataResultComRespDto_2 != null) {
                        calculateDataPointIncDecMeasureAndAmplitudeComReqDto_1.setParentDataResult(preparationPreviousStandardDataResultComRespDto_2.getDataResult());//SimpleFieldAssign//sourceId:1825555_1_69341
                    }
                    if (circulationCollectionsRes != null) {
                        calculateDataPointIncDecMeasureAndAmplitudeComReqDto_1.setDataResult(circulationCollectionsRes.getDataResult());//SimpleFieldAssign//sourceId:1825556_1_69341
                    }

                    /*D4计算数据点增降量与增降幅(公共)[8713]   */
                    Assert.isNull(calculateDataPointIncDecMeasureAndAmplitudeComReqDto_1.getDataResult(), "D4执行刷模板标准数据（运维）-D4计算数据点增降量与增降幅(公共)-数据值结果不能为空", false);
                    calculateDataPointIncDecMeasureAndAmplitudeComRespDto_2 = targetCalcService.calculateDataPointIncDecMeasureAndAmplitudeCom(calculateDataPointIncDecMeasureAndAmplitudeComReqDto_1)/*vcase invoke isSameApp*/;


                }
                boolean bOOLEAN;
                if (preparationPreviousStandardDataResultComRespDto != null && calculateDataPointIncDecMeasureAndAmplitudeComRespDto != null && preparationPreviousStandardDataResultComRespDto_2 != null && calculateDataPointIncDecMeasureAndAmplitudeComRespDto_2 != null && obtainTargetBelongCycleComRespDto != null) {
                    OmsStandardDataResult omsStandardDataResult = new OmsStandardDataResult();
                    if (circulationCollectionsRes != null) {
                        omsStandardDataResult.setDataResultId(circulationCollectionsRes.getDataResultId());//SimpleFieldAssign//sourceId:1825464_1_69337
                    }
                    if (preparationPreviousStandardDataResultComRespDto != null) {
                        omsStandardDataResult.setParentDataResultId(preparationPreviousStandardDataResultComRespDto.getDataResultId());//SimpleFieldAssign//sourceId:1825493_1_69337
                        omsStandardDataResult.setParentDataResult(preparationPreviousStandardDataResultComRespDto.getDataResult());//SimpleFieldAssign//sourceId:1825494_1_69337
                    }
                    if (calculateDataPointIncDecMeasureAndAmplitudeComRespDto != null) {
                        omsStandardDataResult.setChangeFromLastValue(calculateDataPointIncDecMeasureAndAmplitudeComRespDto.getChangeFromLastValue());//SimpleFieldAssign//sourceId:1825495_1_69337
                        omsStandardDataResult.setChangeFromLastRatio(calculateDataPointIncDecMeasureAndAmplitudeComRespDto.getChangeFromLastRatio());//SimpleFieldAssign//sourceId:1825496_1_69337
                    }
                    if (preparationPreviousStandardDataResultComRespDto_2 != null) {
                        omsStandardDataResult.setUpdateCycleParentDataResultId(preparationPreviousStandardDataResultComRespDto_2.getDataResultId());//SimpleFieldAssign//sourceId:1825568_1_69337
                        omsStandardDataResult.setUpdateCycleParentDataResult(preparationPreviousStandardDataResultComRespDto_2.getDataResult());//SimpleFieldAssign//sourceId:1825569_1_69337
                    }
                    if (calculateDataPointIncDecMeasureAndAmplitudeComRespDto_2 != null) {
                        omsStandardDataResult.setUpdateCycleChangeFromLastValue(calculateDataPointIncDecMeasureAndAmplitudeComRespDto_2.getChangeFromLastValue());//SimpleFieldAssign//sourceId:1825570_1_69337
                        omsStandardDataResult.setUpdateCycleChangeFromLastRatio(calculateDataPointIncDecMeasureAndAmplitudeComRespDto_2.getChangeFromLastRatio());//SimpleFieldAssign//sourceId:1825571_1_69337
                    }
                    if (obtainTargetBelongCycleComRespDto != null) {
                        omsStandardDataResult.setStandardDataCalcCycleModel(obtainTargetBelongCycleComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1825497_1_69337
                        omsStandardDataResult.setParentSubMidCycleType(obtainTargetBelongCycleComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1825498_1_69337
                        omsStandardDataResult.setExtendedField3(obtainTargetBelongCycleComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1825499_1_69337
                        omsStandardDataResult.setExtendedField4(obtainTargetBelongCycleComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1825500_1_69337
                        omsStandardDataResult.setBelongToPersonalIdentityRoleCode(obtainTargetBelongCycleComRespDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1825501_1_69337
                    }

                    /*4-01-01修改标准数据[2860]   */
                    Assert.isNull(omsStandardDataResult.getDataResultId(), "D4执行刷模板标准数据（运维）-4-01-01修改标准数据-数据结果ID 不能为空", false);
                    Assert.isNull(omsStandardDataResult.getStandardDataCalcCycleModel(), "D4执行刷模板标准数据（运维）-4-01-01修改标准数据-计算周期五模型不能为空", false);
                    Assert.isNull(omsStandardDataResult.getParentSubMidCycleType(), "D4执行刷模板标准数据（运维）-4-01-01修改标准数据-父子中周期类型不能为空", false);
                    Assert.isNull(omsStandardDataResult.getExtendedField3(), "D4执行刷模板标准数据（运维）-4-01-01修改标准数据-扩展字段3不能为空", false);
                    Assert.isNull(omsStandardDataResult.getExtendedField4(), "D4执行刷模板标准数据（运维）-4-01-01修改标准数据-扩展字段4不能为空", false);
                    bOOLEAN = mOmsStandardDataResultService.updateStandardData(omsStandardDataResult)/*vcase invoke 本地 method 方法调用;*/;


                }
//ModelCode: circulationEnd
            }

        }
        ImplementBrushTempStandardDataRespDto retData = new ImplementBrushTempStandardDataRespDto();


        return retData;
    }

    /**
     * D4执行修复已产生的标准数据(公共)[9790]
     * gen by moon at 6/13/2024, 4:38:45 PM
     */
    @Trace(operationName = "D4执行修复已产生的标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementRepairTheGeneratedStandardDataComRespDto implementRepairTheGeneratedStandardDataCom(ImplementRepairTheGeneratedStandardDataComReqDto reqDto) {


        //virtualUsage D3分析公共字段(公共)  69938
        AnalysisCommonDataComRespDto analysisCommonDataComRespDto = null;
        AnalysisCommonDataComReqDto analysisCommonDataComReqDto = new AnalysisCommonDataComReqDto();
        if (reqDto != null) {
            analysisCommonDataComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:1864739_1_69938
            analysisCommonDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1864740_1_69938
            analysisCommonDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1864741_1_69938
        }

        /*D3分析公共字段(公共)[9793]   */
        Assert.isNull(analysisCommonDataComReqDto.getEvaluationTemplateId(), "D4执行修复已产生的标准数据(公共)-D3分析公共字段(公共)-冗余评价模板ID不能为空", false);
        analysisCommonDataComRespDto = fwAppSystemTestDomainClient.analysisCommonDataCom(analysisCommonDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage D3查目标归属周期详情(公共)  69930
        QueryTargetBeCycleDetailComRespDto queryTargetBeCycleDetailComRespDto = null;
        QueryTargetBeCycleDetailComReqDto queryTargetBeCycleDetailComReqDto = new QueryTargetBeCycleDetailComReqDto();
        if (reqDto != null) {
            queryTargetBeCycleDetailComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1864128_1_69930
            queryTargetBeCycleDetailComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1864129_1_69930
            queryTargetBeCycleDetailComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1864130_1_69930
            queryTargetBeCycleDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1864131_1_69930
        }

        /*D3查目标归属周期详情(公共)[9544]   */
        Assert.isNull(queryTargetBeCycleDetailComReqDto.getCycleId(), "D4执行修复已产生的标准数据(公共)-D3查目标归属周期详情(公共)-归属周期ID不能为空", false);
        Assert.isNull(queryTargetBeCycleDetailComReqDto.getEntityId(), "D4执行修复已产生的标准数据(公共)-D3查目标归属周期详情(公共)-归属内容表主键ID不能为空", false);
        Assert.isNull(queryTargetBeCycleDetailComReqDto.getParentSubMidCycleType(), "D4执行修复已产生的标准数据(公共)-D3查目标归属周期详情(公共)-父子中过程周期类型不能为空", false);
        Assert.isNull(queryTargetBeCycleDetailComReqDto.getEvaluationTemplateId(), "D4执行修复已产生的标准数据(公共)-D3查目标归属周期详情(公共)-冗余评价模板ID不能为空", false);
        queryTargetBeCycleDetailComRespDto = fwAppTargetCalcClient.queryTargetBeCycleDetailCom(queryTargetBeCycleDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage D4分析修复标准数据填报责任人对象ID(公共)  69946
        AnalysisRepairStandardPersonLiableObjIdComRespDto analysisRepairStandardPersonLiableObjIdComRespDto = null;
        if (queryTargetBeCycleDetailComRespDto != null) {
            AnalysisRepairStandardPersonLiableObjIdComReqDto analysisRepairStandardPersonLiableObjIdComReqDto = new AnalysisRepairStandardPersonLiableObjIdComReqDto();
            if (reqDto != null) {
                analysisRepairStandardPersonLiableObjIdComReqDto.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1865270_1_69946
                analysisRepairStandardPersonLiableObjIdComReqDto.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1865286_1_69946
                analysisRepairStandardPersonLiableObjIdComReqDto.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1865287_1_69946
                analysisRepairStandardPersonLiableObjIdComReqDto.setPersonLiableObjStanddardId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1865279_1_69946
            }
            if (queryTargetBeCycleDetailComRespDto != null) {
                analysisRepairStandardPersonLiableObjIdComReqDto.setPersonLiableObjId(queryTargetBeCycleDetailComRespDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1865271_1_69946
            }

            /*D4分析修复标准数据填报责任人对象ID(公共)[9799]   */
            Assert.isNull(analysisRepairStandardPersonLiableObjIdComReqDto.getDataType(), "D4执行修复已产生的标准数据(公共)-D4分析修复标准数据填报责任人对象ID(公共)-数据点类型不能为空", false);
            Assert.isNull(analysisRepairStandardPersonLiableObjIdComReqDto.getBelongToContentId(), "D4执行修复已产生的标准数据(公共)-D4分析修复标准数据填报责任人对象ID(公共)-数据归属内容表主键ID不能为空", false);
            Assert.isNull(analysisRepairStandardPersonLiableObjIdComReqDto.getPersonLiableObjId(), "D4执行修复已产生的标准数据(公共)-D4分析修复标准数据填报责任人对象ID(公共)-填报评价责任人对象ID不能为空", false);
            Assert.isNull(analysisRepairStandardPersonLiableObjIdComReqDto.getBizRoleObjCode(), "D4执行修复已产生的标准数据(公共)-D4分析修复标准数据填报责任人对象ID(公共)-填报评价责任人业务角色标识不能为空", false);
            Assert.isNull(analysisRepairStandardPersonLiableObjIdComReqDto.getPersonLiableObjStanddardId(), "D4执行修复已产生的标准数据(公共)-D4分析修复标准数据填报责任人对象ID(公共)-标准数据报评价责任人对象ID不能为空", false);
            analysisRepairStandardPersonLiableObjIdComRespDto = analysisRepairStandardPersonLiableObjIdCom(analysisRepairStandardPersonLiableObjIdComReqDto)/*vcase invoke 同服务,同domain*/;


        }
//virtualUsage D3-查询上一个执行周期的周期及目标周期详情(公共)  69940
        QueryLastExecCycleAndTargetCycleDetailComRespDto queryLastExecCycleAndTargetCycleDetailComRespDto = null;
        QueryLastExecCycleAndTargetCycleDetailComReqDto queryLastExecCycleAndTargetCycleDetailComReqDto = new QueryLastExecCycleAndTargetCycleDetailComReqDto();
        if (reqDto != null) {
            queryLastExecCycleAndTargetCycleDetailComReqDto.setCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1865109_1_69940
            queryLastExecCycleAndTargetCycleDetailComReqDto.setEvaObjTargetCycleId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1865108_1_69940
            queryLastExecCycleAndTargetCycleDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1865110_1_69940
        }

        /*D3-查询上一个执行周期的周期及目标周期详情(公共)[7507]   */
        Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getCycleId(), "D4执行修复已产生的标准数据(公共)-D3-查询上一个执行周期的周期及目标周期详情(公共)-周期ID不能为空", false);
        Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getEvaObjTargetCycleId(), "D4执行修复已产生的标准数据(公共)-D3-查询上一个执行周期的周期及目标周期详情(公共)-被评对象目标周期ID不能为空", false);
        Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getEvaluationTemplateId(), "D4执行修复已产生的标准数据(公共)-D3-查询上一个执行周期的周期及目标周期详情(公共)-冗余评价模板ID不能为空", false);
        queryLastExecCycleAndTargetCycleDetailComRespDto = fwAppExecuteCycleClient.queryLastExecCycleAndTargetCycleDetailCom(queryLastExecCycleAndTargetCycleDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage D4分析修复标准数据上一周期相关数据(公共)  69939
        AnalysisRepairStandardPreDataComRespDto analysisRepairStandardPreDataComRespDto = null;
        if (queryTargetBeCycleDetailComRespDto != null && queryLastExecCycleAndTargetCycleDetailComRespDto != null) {
            AnalysisRepairStandardPreDataComReqDto analysisRepairStandardPreDataComReqDto = new AnalysisRepairStandardPreDataComReqDto();
            if (reqDto != null) {
                analysisRepairStandardPreDataComReqDto.setDataResult(reqDto.getDataResult());//SimpleFieldAssign//sourceId:1865012_1_69939
                analysisRepairStandardPreDataComReqDto.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1864992_1_69939
                analysisRepairStandardPreDataComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1864993_1_69939
                analysisRepairStandardPreDataComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1864994_1_69939
            }
            if (queryTargetBeCycleDetailComRespDto != null) {
                analysisRepairStandardPreDataComReqDto.setPreviousCycleId(queryTargetBeCycleDetailComRespDto.getPreviousCycleId());//SimpleFieldAssign//sourceId:1865014_1_69939
                analysisRepairStandardPreDataComReqDto.setLastEvaObjTargetCycleId(queryTargetBeCycleDetailComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1865013_1_69939
                analysisRepairStandardPreDataComReqDto.setBizRoleObjCode(queryTargetBeCycleDetailComRespDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1864995_1_69939
                analysisRepairStandardPreDataComReqDto.setBelongToPersonalIdentityRoleCode(queryTargetBeCycleDetailComRespDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1864996_1_69939
                analysisRepairStandardPreDataComReqDto.setBelongToPersonalIdentityId(queryTargetBeCycleDetailComRespDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1864997_1_69939
                analysisRepairStandardPreDataComReqDto.setExtendedField3(queryTargetBeCycleDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1865001_1_69939
                analysisRepairStandardPreDataComReqDto.setExtendedField4(queryTargetBeCycleDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1865002_1_69939
            }
            if (queryLastExecCycleAndTargetCycleDetailComRespDto != null) {
                analysisRepairStandardPreDataComReqDto.setPreUpdateCycleId(queryLastExecCycleAndTargetCycleDetailComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1865015_1_69939
            }

            /*D4分析修复标准数据上一周期相关数据(公共)[9794]   */
            Assert.isNull(analysisRepairStandardPreDataComReqDto.getDataResult(), "D4执行修复已产生的标准数据(公共)-D4分析修复标准数据上一周期相关数据(公共)-数据值结果不能为空", false);
            Assert.isNull(analysisRepairStandardPreDataComReqDto.getDataType(), "D4执行修复已产生的标准数据(公共)-D4分析修复标准数据上一周期相关数据(公共)-数据点类型不能为空", false);
            Assert.isNull(analysisRepairStandardPreDataComReqDto.getEntityId(), "D4执行修复已产生的标准数据(公共)-D4分析修复标准数据上一周期相关数据(公共)-归属内容表主键ID不能为空", false);
            Assert.isNull(analysisRepairStandardPreDataComReqDto.getThemeContentId(), "D4执行修复已产生的标准数据(公共)-D4分析修复标准数据上一周期相关数据(公共)-主题内容ID不能为空", false);
            Assert.isNull(analysisRepairStandardPreDataComReqDto.getBizRoleObjCode(), "D4执行修复已产生的标准数据(公共)-D4分析修复标准数据上一周期相关数据(公共)-填报评价责任人业务角色标识不能为空", false);
            Assert.isNull(analysisRepairStandardPreDataComReqDto.getBelongToPersonalIdentityRoleCode(), "D4执行修复已产生的标准数据(公共)-D4分析修复标准数据上一周期相关数据(公共)-数据归属对象角色编码不能为空", false);
            Assert.isNull(analysisRepairStandardPreDataComReqDto.getBelongToPersonalIdentityId(), "D4执行修复已产生的标准数据(公共)-D4分析修复标准数据上一周期相关数据(公共)-数据归属对象ID不能为空", false);
            Assert.isNull(analysisRepairStandardPreDataComReqDto.getExtendedField3(), "D4执行修复已产生的标准数据(公共)-D4分析修复标准数据上一周期相关数据(公共)-扩展字段3不能为空", false);
            Assert.isNull(analysisRepairStandardPreDataComReqDto.getExtendedField4(), "D4执行修复已产生的标准数据(公共)-D4分析修复标准数据上一周期相关数据(公共)-扩展字段4不能为空", false);
            analysisRepairStandardPreDataComRespDto = analysisRepairStandardPreDataCom(analysisRepairStandardPreDataComReqDto)/*vcase invoke 同服务,同domain*/;


        }
//virtualUsage D4-1修改标准数据(公共)  69932
        UpdateStandardDataComRespDto updateStandardDataComRespDto = null;
        if (analysisRepairStandardPreDataComRespDto != null && analysisCommonDataComRespDto != null && queryTargetBeCycleDetailComRespDto != null && analysisRepairStandardPersonLiableObjIdComRespDto != null) {
            UpdateStandardDataComReqDto updateStandardDataComReqDto = new UpdateStandardDataComReqDto();
            if (reqDto != null) {
                updateStandardDataComReqDto.setDataResultId(reqDto.getDataResultId());//SimpleFieldAssign//sourceId:1864118_1_69932
            }
            if (analysisRepairStandardPreDataComRespDto != null) {
                updateStandardDataComReqDto.setParentDataResultId(analysisRepairStandardPreDataComRespDto.getParentDataResultId());//SimpleFieldAssign//sourceId:1864709_1_69932
                updateStandardDataComReqDto.setParentDataResult(analysisRepairStandardPreDataComRespDto.getParentDataResult());//SimpleFieldAssign//sourceId:1864710_1_69932
                updateStandardDataComReqDto.setChangeFromLastValue(analysisRepairStandardPreDataComRespDto.getChangeFromLastValue());//SimpleFieldAssign//sourceId:1864711_1_69932
                updateStandardDataComReqDto.setChangeFromLastRatio(analysisRepairStandardPreDataComRespDto.getChangeFromLastRatio());//SimpleFieldAssign//sourceId:1864712_1_69932
                updateStandardDataComReqDto.setUpdateCycleParentDataResultId(analysisRepairStandardPreDataComRespDto.getUpdateCycleParentDataResultId());//SimpleFieldAssign//sourceId:1864713_1_69932
                updateStandardDataComReqDto.setUpdateCycleParentDataResult(analysisRepairStandardPreDataComRespDto.getUpdateCycleParentDataResult());//SimpleFieldAssign//sourceId:1864714_1_69932
                updateStandardDataComReqDto.setUpdateCycleChangeFromLastValue(analysisRepairStandardPreDataComRespDto.getUpdateCycleChangeFromLastValue());//SimpleFieldAssign//sourceId:1864715_1_69932
                updateStandardDataComReqDto.setUpdateCycleChangeFromLastRatio(analysisRepairStandardPreDataComRespDto.getUpdateCycleChangeFromLastRatio());//SimpleFieldAssign//sourceId:1864716_1_69932
            }
            if (analysisCommonDataComRespDto != null) {
                updateStandardDataComReqDto.setEventBatchUpdateCode(analysisCommonDataComRespDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:1864233_1_69932
                updateStandardDataComReqDto.setCalcStartTime(analysisCommonDataComRespDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1864234_1_69932
            }
            if (queryTargetBeCycleDetailComRespDto != null) {
                updateStandardDataComReqDto.setIsWorkCycleData(queryTargetBeCycleDetailComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1864127_1_69932
                updateStandardDataComReqDto.setExtendedField3(queryTargetBeCycleDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1864124_1_69932
                updateStandardDataComReqDto.setExtendedField4(queryTargetBeCycleDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1864125_1_69932
                updateStandardDataComReqDto.setBelongToPersonalIdentityTypeCode(queryTargetBeCycleDetailComRespDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1864120_1_69932
                updateStandardDataComReqDto.setBelongToPersonalIdentityRoleCode(queryTargetBeCycleDetailComRespDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1864126_1_69932
                updateStandardDataComReqDto.setBelongToPersonalIdentityId(queryTargetBeCycleDetailComRespDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1864121_1_69932
            }
            if (analysisRepairStandardPersonLiableObjIdComRespDto != null) {
                updateStandardDataComReqDto.setPersonLiableObjId(analysisRepairStandardPersonLiableObjIdComRespDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1864235_1_69932
            }

            /*D4-1修改标准数据(公共)[3047]   */
            Assert.isNull(updateStandardDataComReqDto.getDataResultId(), "D4执行修复已产生的标准数据(公共)-D4-1修改标准数据(公共)-数据结果ID 不能为空", false);
            Assert.isNull(updateStandardDataComReqDto.getIsWorkCycleData(), "D4执行修复已产生的标准数据(公共)-D4-1修改标准数据(公共)-是否工作周期数据不能为空", false);
            Assert.isNull(updateStandardDataComReqDto.getExtendedField3(), "D4执行修复已产生的标准数据(公共)-D4-1修改标准数据(公共)-扩展字段3不能为空", false);
            Assert.isNull(updateStandardDataComReqDto.getExtendedField4(), "D4执行修复已产生的标准数据(公共)-D4-1修改标准数据(公共)-扩展字段4不能为空", false);
//Assert.isNull(updateStandardDataComReqDto.getPersonLiableObjId(),"D4执行修复已产生的标准数据(公共)-D4-1修改标准数据(公共)-填报评价责任人对象ID不能为空",false);
            Assert.isNull(updateStandardDataComReqDto.getBelongToPersonalIdentityTypeCode(), "D4执行修复已产生的标准数据(公共)-D4-1修改标准数据(公共)-数据归属对象类型编码不能为空", false);
            Assert.isNull(updateStandardDataComReqDto.getBelongToPersonalIdentityRoleCode(), "D4执行修复已产生的标准数据(公共)-D4-1修改标准数据(公共)-数据归属对象角色编码不能为空", false);
            Assert.isNull(updateStandardDataComReqDto.getBelongToPersonalIdentityId(), "D4执行修复已产生的标准数据(公共)-D4-1修改标准数据(公共)-数据归属对象ID不能为空", false);
            updateStandardDataComRespDto = standardDataService.updateStandardDataCom(updateStandardDataComReqDto)/*vcase invoke isSameApp*/;


        }
        ImplementRepairTheGeneratedStandardDataComRespDto retData = new ImplementRepairTheGeneratedStandardDataComRespDto();


        return retData;
    }

    /**
     * D4分析修复标准数据上一周期相关数据(公共)[9794]
     * gen by moon at 6/13/2024, 4:38:47 PM
     */
    @Trace(operationName = "D4分析修复标准数据上一周期相关数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AnalysisRepairStandardPreDataComRespDto analysisRepairStandardPreDataCom(AnalysisRepairStandardPreDataComReqDto reqDto) {


        ImplementCalcReceivingField005RespDto receptionServiceRes_2 = null;
//步骤0: M4执行计算接收字段001（特殊方法） - implementCalcReceivingField001
        //ModelCode: receptionService
        ImplementCalcReceivingField001RespDto receptionServiceRes = null;
        ImplementCalcReceivingField001ReqDto receptionServiceReq = new ImplementCalcReceivingField001ReqDto();
        if (reqDto != null) {
            receptionServiceReq.setDataResult(reqDto.getDataResult());//SimpleFieldAssign//sourceId:1864979_1
            receptionServiceReq.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1864863_1
            receptionServiceReq.setLastEvaObjTargetCycleId(reqDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1864986_1
            receptionServiceReq.setPreviousCycleId(reqDto.getPreviousCycleId());//SimpleFieldAssign//sourceId:1864987_1
            receptionServiceReq.setPreUpdateCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:1864988_1
            receptionServiceReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1864865_1
            receptionServiceReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1864866_1
            receptionServiceReq.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1864867_1
            receptionServiceReq.setBelongToPersonalIdentityRoleCode(reqDto.getBelongToPersonalIdentityRoleCode());//SimpleFieldAssign//sourceId:1864869_1
            receptionServiceReq.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1864868_1
            receptionServiceReq.setAccountId(reqDto.getAccountId());//SimpleFieldAssign//sourceId:1864870_1
            receptionServiceReq.setExtendedField1(reqDto.getExtendedField1());//SimpleFieldAssign//sourceId:1864874_1
            receptionServiceReq.setExtendedField2(reqDto.getExtendedField2());//SimpleFieldAssign//sourceId:1864871_1
            receptionServiceReq.setExtendedField3(reqDto.getExtendedField3());//SimpleFieldAssign//sourceId:1864875_1
            receptionServiceReq.setExtendedField4(reqDto.getExtendedField4());//SimpleFieldAssign//sourceId:1864872_1
            receptionServiceReq.setExtendedField5(reqDto.getExtendedField5());//SimpleFieldAssign//sourceId:1864873_1
        }

        /*M4接收入参字段[9535]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getDataResult(), "D4分析修复标准数据上一周期相关数据(公共)-M4接收入参字段-数据值结果不能为空", false);
        Assert.isNull(receptionServiceReq.getDataType(), "D4分析修复标准数据上一周期相关数据(公共)-M4接收入参字段-数据点类型不能为空", false);
        receptionServiceRes = nbSystemTestDomain.implementCalcReceivingField001(receptionServiceReq);


//步骤1: D4准备上一标准数据结果(公共) - preparationPreviousStandardDataResultCom
        PreparationPreviousStandardDataResultComRespDto preparationPreviousStandardDataResultComRespDto = null;
        PreparationPreviousStandardDataResultComReqDto preparationPreviousStandardDataResultComReqDto = new PreparationPreviousStandardDataResultComReqDto();
        if (reqDto != null) {
            preparationPreviousStandardDataResultComReqDto.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1864826_1
            preparationPreviousStandardDataResultComReqDto.setCycleId(reqDto.getPreviousCycleId());//SimpleFieldAssign//sourceId:1864825_1
            preparationPreviousStandardDataResultComReqDto.setEntityId(reqDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1864830_1
            preparationPreviousStandardDataResultComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1864835_1
            preparationPreviousStandardDataResultComReqDto.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1864829_1
            preparationPreviousStandardDataResultComReqDto.setBelongToPersonalIdentityRoleCode(reqDto.getBelongToPersonalIdentityRoleCode());//SimpleFieldAssign//sourceId:1864831_1
            preparationPreviousStandardDataResultComReqDto.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1864832_1
            preparationPreviousStandardDataResultComReqDto.setAccountId(reqDto.getAccountId());//SimpleFieldAssign//sourceId:1864839_1
            preparationPreviousStandardDataResultComReqDto.setExtendedField1(reqDto.getExtendedField1());//SimpleFieldAssign//sourceId:1864833_1
            preparationPreviousStandardDataResultComReqDto.setExtendedField2(reqDto.getExtendedField2());//SimpleFieldAssign//sourceId:1864836_1
            preparationPreviousStandardDataResultComReqDto.setExtendedField3(reqDto.getExtendedField3());//SimpleFieldAssign//sourceId:1864834_1
            preparationPreviousStandardDataResultComReqDto.setExtendedField4(reqDto.getExtendedField4());//SimpleFieldAssign//sourceId:1864837_1
            preparationPreviousStandardDataResultComReqDto.setExtendedField5(reqDto.getExtendedField5());//SimpleFieldAssign//sourceId:1864838_1
        }

        /*D4准备上一归属标准数据结果(公共)[8542]   */
        Assert.isNull(preparationPreviousStandardDataResultComReqDto.getDataType(), "D4分析修复标准数据上一周期相关数据(公共)-D4准备上一归属标准数据结果(公共)-数据点类型不能为空", false);
        preparationPreviousStandardDataResultComRespDto = standardDataService.preparationPreviousStandardDataResultCom(preparationPreviousStandardDataResultComReqDto)/*vcase invoke isSameApp*/;


//步骤2: D4计算数据点增降量与增降幅(公共) - calculateDataPointIncDecMeasureAndAmplitudeCom
        CalculateDataPointIncDecMeasureAndAmplitudeComRespDto calculateDataPointIncDecMeasureAndAmplitudeComRespDto = null;
        if (preparationPreviousStandardDataResultComRespDto != null) {
            CalculateDataPointIncDecMeasureAndAmplitudeComReqDto calculateDataPointIncDecMeasureAndAmplitudeComReqDto = new CalculateDataPointIncDecMeasureAndAmplitudeComReqDto();
            if (preparationPreviousStandardDataResultComRespDto != null) {
                calculateDataPointIncDecMeasureAndAmplitudeComReqDto.setParentDataResult(preparationPreviousStandardDataResultComRespDto.getDataResult());//SimpleFieldAssign//sourceId:1864840_1
            }
            if (reqDto != null) {
                calculateDataPointIncDecMeasureAndAmplitudeComReqDto.setDataResult(reqDto.getDataResult());//SimpleFieldAssign//sourceId:1864841_1
            }

            /*D4计算归属数据点增降量与增降幅(公共)[8713]   */
            Assert.isNull(calculateDataPointIncDecMeasureAndAmplitudeComReqDto.getDataResult(), "D4分析修复标准数据上一周期相关数据(公共)-D4计算归属数据点增降量与增降幅(公共)-数据值结果不能为空", false);
            calculateDataPointIncDecMeasureAndAmplitudeComRespDto = targetCalcService.calculateDataPointIncDecMeasureAndAmplitudeCom(calculateDataPointIncDecMeasureAndAmplitudeComReqDto)/*vcase invoke isSameApp*/;


        }

//步骤3: D4准备上一标准数据结果(公共) - preparationPreviousStandardDataResultCom
        PreparationPreviousStandardDataResultComRespDto preparationPreviousStandardDataResultComRespDto_2 = null;
        PreparationPreviousStandardDataResultComReqDto preparationPreviousStandardDataResultComReqDto_1 = new PreparationPreviousStandardDataResultComReqDto();
        if (reqDto != null) {
            preparationPreviousStandardDataResultComReqDto_1.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1864845_1
            preparationPreviousStandardDataResultComReqDto_1.setCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:1864844_1
            preparationPreviousStandardDataResultComReqDto_1.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1864849_1
            preparationPreviousStandardDataResultComReqDto_1.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1864854_1
            preparationPreviousStandardDataResultComReqDto_1.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1864848_1
            preparationPreviousStandardDataResultComReqDto_1.setBelongToPersonalIdentityRoleCode(reqDto.getBelongToPersonalIdentityRoleCode());//SimpleFieldAssign//sourceId:1864850_1
            preparationPreviousStandardDataResultComReqDto_1.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1864851_1
            preparationPreviousStandardDataResultComReqDto_1.setAccountId(reqDto.getAccountId());//SimpleFieldAssign//sourceId:1864858_1
            preparationPreviousStandardDataResultComReqDto_1.setExtendedField1(reqDto.getExtendedField1());//SimpleFieldAssign//sourceId:1864852_1
            preparationPreviousStandardDataResultComReqDto_1.setExtendedField2(reqDto.getExtendedField2());//SimpleFieldAssign//sourceId:1864855_1
            preparationPreviousStandardDataResultComReqDto_1.setExtendedField3(reqDto.getExtendedField3());//SimpleFieldAssign//sourceId:1864853_1
            preparationPreviousStandardDataResultComReqDto_1.setExtendedField4(reqDto.getExtendedField4());//SimpleFieldAssign//sourceId:1864856_1
            preparationPreviousStandardDataResultComReqDto_1.setExtendedField5(reqDto.getExtendedField5());//SimpleFieldAssign//sourceId:1864857_1
        }

        /*D4准备上一更新标准数据结果(公共)[8542]   */
        Assert.isNull(preparationPreviousStandardDataResultComReqDto_1.getDataType(), "D4分析修复标准数据上一周期相关数据(公共)-D4准备上一更新标准数据结果(公共)-数据点类型不能为空", false);
        preparationPreviousStandardDataResultComRespDto_2 = standardDataService.preparationPreviousStandardDataResultCom(preparationPreviousStandardDataResultComReqDto_1)/*vcase invoke isSameApp*/;


//步骤4: D4计算数据点增降量与增降幅(公共) - calculateDataPointIncDecMeasureAndAmplitudeCom
        CalculateDataPointIncDecMeasureAndAmplitudeComRespDto calculateDataPointIncDecMeasureAndAmplitudeComRespDto_2 = null;
        if (preparationPreviousStandardDataResultComRespDto_2 != null) {
            CalculateDataPointIncDecMeasureAndAmplitudeComReqDto calculateDataPointIncDecMeasureAndAmplitudeComReqDto_1 = new CalculateDataPointIncDecMeasureAndAmplitudeComReqDto();
            if (preparationPreviousStandardDataResultComRespDto_2 != null) {
                calculateDataPointIncDecMeasureAndAmplitudeComReqDto_1.setParentDataResult(preparationPreviousStandardDataResultComRespDto_2.getDataResult());//SimpleFieldAssign//sourceId:1864859_1
            }
            if (reqDto != null) {
                calculateDataPointIncDecMeasureAndAmplitudeComReqDto_1.setDataResult(reqDto.getDataResult());//SimpleFieldAssign//sourceId:1864860_1
            }

            /*D4计算更新数据点增降量与增降幅(公共)[8713]   */
            Assert.isNull(calculateDataPointIncDecMeasureAndAmplitudeComReqDto_1.getDataResult(), "D4分析修复标准数据上一周期相关数据(公共)-D4计算更新数据点增降量与增降幅(公共)-数据值结果不能为空", false);
            calculateDataPointIncDecMeasureAndAmplitudeComRespDto_2 = targetCalcService.calculateDataPointIncDecMeasureAndAmplitudeCom(calculateDataPointIncDecMeasureAndAmplitudeComReqDto_1)/*vcase invoke isSameApp*/;


        }

//步骤5: M4执行计算接收字段005（特殊方法） - implementCalcReceivingField005
        //ModelCode: receptionService
        ImplementCalcReceivingField005RespDto receptionServiceRes_1 = null;
        if (preparationPreviousStandardDataResultComRespDto != null) {
            ImplementCalcReceivingField005ReqDto receptionServiceReq_1 = new ImplementCalcReceivingField005ReqDto();
            if (preparationPreviousStandardDataResultComRespDto != null) {
                receptionServiceReq_1.setParentDataResultId(preparationPreviousStandardDataResultComRespDto.getDataResultId());//SimpleFieldAssign//sourceId:1864955_1
                receptionServiceReq_1.setParentDataResult(preparationPreviousStandardDataResultComRespDto.getDataResult());//SimpleFieldAssign//sourceId:1864956_1
            }
            if (calculateDataPointIncDecMeasureAndAmplitudeComRespDto != null) {
                receptionServiceReq_1.setChangeFromLastValue(calculateDataPointIncDecMeasureAndAmplitudeComRespDto.getChangeFromLastValue());//SimpleFieldAssign//sourceId:1864957_1
                receptionServiceReq_1.setChangeFromLastRatio(calculateDataPointIncDecMeasureAndAmplitudeComRespDto.getChangeFromLastRatio());//SimpleFieldAssign//sourceId:1864958_1
            }
            if (preparationPreviousStandardDataResultComRespDto_2 != null) {
                receptionServiceReq_1.setUpdateCycleParentDataResultId(preparationPreviousStandardDataResultComRespDto_2.getDataResultId());//SimpleFieldAssign//sourceId:1864959_1
                receptionServiceReq_1.setUpdateCycleParentDataResult(preparationPreviousStandardDataResultComRespDto_2.getDataResult());//SimpleFieldAssign//sourceId:1864960_1
            }
            if (calculateDataPointIncDecMeasureAndAmplitudeComRespDto_2 != null) {
                receptionServiceReq_1.setUpdateCycleChangeFromLastValue(calculateDataPointIncDecMeasureAndAmplitudeComRespDto_2.getChangeFromLastValue());//SimpleFieldAssign//sourceId:1864961_1
                receptionServiceReq_1.setUpdateCycleChangeFromLastRatio(calculateDataPointIncDecMeasureAndAmplitudeComRespDto_2.getChangeFromLastRatio());//SimpleFieldAssign//sourceId:1864962_1
            }

            /*M4接收出参字段[9539]  用于特殊方法接收上游入参。 */

            receptionServiceRes_1 = nbSystemTestDomain.implementCalcReceivingField005(receptionServiceReq_1);


            receptionServiceRes_2 = receptionServiceRes_1;
        }

        AnalysisRepairStandardPreDataComRespDto retData = new AnalysisRepairStandardPreDataComRespDto();
        if (receptionServiceRes_2 != null) {
            retData.setParentDataResultId(receptionServiceRes_2.getParentDataResultId());//SimpleFieldAssign//sourceId:1864971_1
            retData.setParentDataResult(receptionServiceRes_2.getParentDataResult());//SimpleFieldAssign//sourceId:1864972_1
            retData.setChangeFromLastValue(receptionServiceRes_2.getChangeFromLastValue());//SimpleFieldAssign//sourceId:1864973_1
            retData.setChangeFromLastRatio(receptionServiceRes_2.getChangeFromLastRatio());//SimpleFieldAssign//sourceId:1864974_1
            retData.setUpdateCycleParentDataResultId(receptionServiceRes_2.getUpdateCycleParentDataResultId());//SimpleFieldAssign//sourceId:1864975_1
            retData.setUpdateCycleParentDataResult(receptionServiceRes_2.getUpdateCycleParentDataResult());//SimpleFieldAssign//sourceId:1864976_1
            retData.setUpdateCycleChangeFromLastValue(receptionServiceRes_2.getUpdateCycleChangeFromLastValue());//SimpleFieldAssign//sourceId:1864977_1
            retData.setUpdateCycleChangeFromLastRatio(receptionServiceRes_2.getUpdateCycleChangeFromLastRatio());//SimpleFieldAssign//sourceId:1864978_1
        }


        return retData;
    }

    /**
     * D4执行修复标准数据(公共)[9795]
     * gen by moon at 6/17/2024, 12:33:28 AM
     */
    @Trace(operationName = "D4执行修复标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementRepairStandardDataComRespDto implementRepairStandardDataCom(ImplementRepairStandardDataComReqDto reqDto) {


        //步骤0: D4查询修复标准数据列表(公共) - queryRepairStandardDataListCom
        QueryRepairStandardDataListComRespDto queryRepairStandardDataListComRespDto = null;
        QueryRepairStandardDataListComReqDto queryRepairStandardDataListComReqDto = new QueryRepairStandardDataListComReqDto();
        queryRepairStandardDataListComReqDto.setIsArchive("FALSE");//sourceId:1873936_1
        if (reqDto != null) {
            queryRepairStandardDataListComReqDto.setResultType(reqDto.getResultType());//SimpleFieldAssign//sourceId:1865404_1
            queryRepairStandardDataListComReqDto.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1865403_1
            queryRepairStandardDataListComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1865054_1
            queryRepairStandardDataListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1865055_1
        }

        /*D4查询修复标准数据列表(公共)[9797]   */
        Assert.isNull(queryRepairStandardDataListComReqDto.getThemeContentId(), "D4执行修复标准数据(公共)-D4查询修复标准数据列表(公共)-主题内容ID不能为空", false);
        Assert.isNull(queryRepairStandardDataListComReqDto.getIsArchive(), "D4执行修复标准数据(公共)-D4查询修复标准数据列表(公共)-是否存档不能为空", false);
        Assert.isNull(queryRepairStandardDataListComReqDto.getSpaceId(), "D4执行修复标准数据(公共)-D4查询修复标准数据列表(公共)-创建于空间ID不能为空", false);
        queryRepairStandardDataListComRespDto = queryRepairStandardDataListCom(queryRepairStandardDataListComReqDto)/*vcase invoke 同服务,同domain*/;


//步骤1: M4执行标准数据【循环开始】 - implementStandardDataLoopStart
        //ModelCode: circulationCollections
        for (StandardDataDto circulationCollectionsRes : queryRepairStandardDataListComRespDto.getStandardDataList()) {


//步骤2: D4执行修复已产生的标准数据(公共) - implementRepairTheGeneratedStandardDataCom
            ImplementRepairTheGeneratedStandardDataComRespDto implementRepairTheGeneratedStandardDataComRespDto = null;
            ImplementRepairTheGeneratedStandardDataComReqDto implementRepairTheGeneratedStandardDataComReqDto = new ImplementRepairTheGeneratedStandardDataComReqDto();
            if (circulationCollectionsRes != null) {
                implementRepairTheGeneratedStandardDataComReqDto.setDataResultId(circulationCollectionsRes.getDataResultId());//SimpleFieldAssign//sourceId:1865087_1
                implementRepairTheGeneratedStandardDataComReqDto.setDataResult(circulationCollectionsRes.getDataResult());//SimpleFieldAssign//sourceId:1865104_1
                implementRepairTheGeneratedStandardDataComReqDto.setDataType(circulationCollectionsRes.getDataType());//SimpleFieldAssign//sourceId:1865105_1
                implementRepairTheGeneratedStandardDataComReqDto.setUpdateCycleId(circulationCollectionsRes.getUpdateCycleId());//SimpleFieldAssign//sourceId:1865123_1
                implementRepairTheGeneratedStandardDataComReqDto.setCycleId(circulationCollectionsRes.getPeriodId());//SimpleFieldAssign//sourceId:1865084_1
                implementRepairTheGeneratedStandardDataComReqDto.setEntityId(circulationCollectionsRes.getEntityId());//SimpleFieldAssign//sourceId:1865085_1
                implementRepairTheGeneratedStandardDataComReqDto.setBelongToContentId(circulationCollectionsRes.getBelongToContentId());//SimpleFieldAssign//sourceId:1865098_1
                implementRepairTheGeneratedStandardDataComReqDto.setParentSubMidCycleType(circulationCollectionsRes.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1865083_1
                implementRepairTheGeneratedStandardDataComReqDto.setPersonLiableObjId(circulationCollectionsRes.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1865090_1
                implementRepairTheGeneratedStandardDataComReqDto.setBizRoleObjCode(circulationCollectionsRes.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1865091_1
                implementRepairTheGeneratedStandardDataComReqDto.setEventBatchUpdateCode(circulationCollectionsRes.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:1865088_1
                implementRepairTheGeneratedStandardDataComReqDto.setCalcStartTime(circulationCollectionsRes.getCalcStartTime());//SimpleFieldAssign//sourceId:1865089_1
            }
            if (reqDto != null) {
                implementRepairTheGeneratedStandardDataComReqDto.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1865086_1
            }

            /*D4执行修复已产生的标准数据(公共)[9790]   */
            Assert.isNull(implementRepairTheGeneratedStandardDataComReqDto.getDataResultId(), "D4执行修复标准数据(公共)-D4执行修复已产生的标准数据(公共)-数据结果ID 不能为空", false);
            Assert.isNull(implementRepairTheGeneratedStandardDataComReqDto.getDataResult(), "D4执行修复标准数据(公共)-D4执行修复已产生的标准数据(公共)-数据值结果不能为空", false);
            Assert.isNull(implementRepairTheGeneratedStandardDataComReqDto.getDataType(), "D4执行修复标准数据(公共)-D4执行修复已产生的标准数据(公共)-数据点类型不能为空", false);
            Assert.isNull(implementRepairTheGeneratedStandardDataComReqDto.getUpdateCycleId(), "D4执行修复标准数据(公共)-D4执行修复已产生的标准数据(公共)-更新周期ID不能为空", false);
            Assert.isNull(implementRepairTheGeneratedStandardDataComReqDto.getCycleId(), "D4执行修复标准数据(公共)-D4执行修复已产生的标准数据(公共)-归属周期ID不能为空", false);
            Assert.isNull(implementRepairTheGeneratedStandardDataComReqDto.getEntityId(), "D4执行修复标准数据(公共)-D4执行修复已产生的标准数据(公共)-归属内容表主键ID不能为空", false);
            Assert.isNull(implementRepairTheGeneratedStandardDataComReqDto.getBelongToContentId(), "D4执行修复标准数据(公共)-D4执行修复已产生的标准数据(公共)-数据归属内容表主键ID不能为空", false);
            Assert.isNull(implementRepairTheGeneratedStandardDataComReqDto.getParentSubMidCycleType(), "D4执行修复标准数据(公共)-D4执行修复已产生的标准数据(公共)-父子中过程周期类型不能为空", false);
            Assert.isNull(implementRepairTheGeneratedStandardDataComReqDto.getEvaluationTemplateId(), "D4执行修复标准数据(公共)-D4执行修复已产生的标准数据(公共)-冗余评价模板ID不能为空", false);
            Assert.isNull(implementRepairTheGeneratedStandardDataComReqDto.getPersonLiableObjId(), "D4执行修复标准数据(公共)-D4执行修复已产生的标准数据(公共)-填报评价责任人对象ID不能为空", false);
            Assert.isNull(implementRepairTheGeneratedStandardDataComReqDto.getBizRoleObjCode(), "D4执行修复标准数据(公共)-D4执行修复已产生的标准数据(公共)-填报评价责任人业务角色标识不能为空", false);
            implementRepairTheGeneratedStandardDataComRespDto = implementRepairTheGeneratedStandardDataCom(implementRepairTheGeneratedStandardDataComReqDto)/*vcase invoke 同服务,同domain*/;


//步骤3: M4-执行【循环结束】 - implementLoopStopCalc
            //ModelCode: circulationEnd
        }


        ImplementRepairStandardDataComRespDto retData = new ImplementRepairStandardDataComRespDto();


        return retData;
    }

    /**
     * D4查询修复标准数据列表(公共)[9797]
     * gen by moon at 6/17/2024, 12:33:34 AM
     */
    @Trace(operationName = "D4查询修复标准数据列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryRepairStandardDataListComRespDto queryRepairStandardDataListCom(QueryRepairStandardDataListComReqDto reqDto) {


        List<OmsStandardDataResult> listOmsStandardDataResult_1 = new ArrayList<>();
//步骤0: M4查询修复标准数据列表 - queryRepairStandardDataList
        List<OmsStandardDataResult> listOmsStandardDataResult = new ArrayList<>();
        QueryRepairStandardDataListReq queryRepairStandardDataListReq = new QueryRepairStandardDataListReq();
        if (reqDto != null) {
            queryRepairStandardDataListReq.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1865399_1
            queryRepairStandardDataListReq.setResultType(reqDto.getResultType());//SimpleFieldAssign//sourceId:1865400_1
            queryRepairStandardDataListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1865048_1
            queryRepairStandardDataListReq.setExtendedField3(reqDto.getExtendedField3());//SimpleFieldAssign//sourceId:1874105_1
            queryRepairStandardDataListReq.setExtendedField4(reqDto.getExtendedField4());//SimpleFieldAssign//sourceId:1874106_1
            queryRepairStandardDataListReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:1873934_1
            queryRepairStandardDataListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1865049_1
        }

        /*M4查询修复标准数据列表[9796]   */
        Assert.isNull(queryRepairStandardDataListReq.getSpaceId(), "D4查询修复标准数据列表(公共)-M4查询修复标准数据列表-创建于空间ID不能为空", false);
        listOmsStandardDataResult = mOmsStandardDataResultService.queryRepairStandardDataList(queryRepairStandardDataListReq)/*vcase invoke 本地 method 方法调用;*/;


        listOmsStandardDataResult_1 = listOmsStandardDataResult;

        QueryRepairStandardDataListComRespDto retData = new QueryRepairStandardDataListComRespDto();
        retData.setStandardDataList(listOmsStandardDataResult_1.stream().map(item -> BeanUtil.toBean(item, StandardDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1865053_1


        return retData;
    }

    /**
     * D4分析修复标准数据填报责任人对象ID(公共)[9799]
     * gen by moon at 6/13/2024, 4:11:11 PM
     */
    @Trace(operationName = "D4分析修复标准数据填报责任人对象ID(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AnalysisRepairStandardPersonLiableObjIdComRespDto analysisRepairStandardPersonLiableObjIdCom(AnalysisRepairStandardPersonLiableObjIdComReqDto reqDto) {


        ImplementCalcReceivingField005RespDto receptionServiceRes_1 = null;
        if ((reqDto != null && reqDto.getDataType() != null && reqDto.getDataType().equals("SUBJECTIVE_MARK"))) {
            //if(D4分析修复标准数据填报责任人对象ID(公共).数据点类型 等于 主观评分)  69941

            QueryVirtualOrgMemberDetailComRespDto queryVirtualOrgMemberDetailComRespDto = null;
            QueryVirtualOrgMemberDetailComReqDto queryVirtualOrgMemberDetailComReqDto = new QueryVirtualOrgMemberDetailComReqDto();
            queryVirtualOrgMemberDetailComReqDto.setIsArchive("FALSE");//sourceId:1865268_1_69943
            if (reqDto != null) {
                queryVirtualOrgMemberDetailComReqDto.setVirtualOrgInductionRecordId(reqDto.getPersonLiableObjStanddardId());//SimpleFieldAssign//sourceId:1865265_1_69943
                queryVirtualOrgMemberDetailComReqDto.setEntityId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1865266_1_69943
                queryVirtualOrgMemberDetailComReqDto.setRoleCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1865267_1_69943
            }

            /*D3-查询虚拟组织成员详情(公共)[5937]   */
            Assert.isNull(queryVirtualOrgMemberDetailComReqDto.getVirtualOrgInductionRecordId(), "D4分析修复标准数据填报责任人对象ID(公共)-D3-查询虚拟组织成员详情(公共)-虚拟组织成员就职记录ID不能为空", false);
            Assert.isNull(queryVirtualOrgMemberDetailComReqDto.getEntityId(), "D4分析修复标准数据填报责任人对象ID(公共)-D3-查询虚拟组织成员详情(公共)-冗余内容表主键ID不能为空", false);
            Assert.isNull(queryVirtualOrgMemberDetailComReqDto.getRoleCode(), "D4分析修复标准数据填报责任人对象ID(公共)-D3-查询虚拟组织成员详情(公共)-角色标识不能为空", false);
            Assert.isNull(queryVirtualOrgMemberDetailComReqDto.getIsArchive(), "D4分析修复标准数据填报责任人对象ID(公共)-D3-查询虚拟组织成员详情(公共)-是否存档不能为空", false);
            queryVirtualOrgMemberDetailComRespDto = fwAppVirtualOrgClient.queryVirtualOrgMemberDetailCom(queryVirtualOrgMemberDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//ModelCode: receptionService
            ImplementCalcReceivingField005RespDto receptionServiceRes = null;
            if (queryVirtualOrgMemberDetailComRespDto != null) {
                ImplementCalcReceivingField005ReqDto receptionServiceReq = new ImplementCalcReceivingField005ReqDto();
                if (queryVirtualOrgMemberDetailComRespDto != null) {
                    receptionServiceReq.setPersonLiableObjId(queryVirtualOrgMemberDetailComRespDto.getVirtualOrgMemberId());//SimpleFieldAssign//sourceId:1865263_1_69944
                }

                /*M4接收填报评价责任人对象ID[9539]  用于特殊方法接收上游入参。 */
//    Assert.isNull(receptionServiceReq.getPersonLiableObjId(),"D4分析修复标准数据填报责任人对象ID(公共)-M4接收填报评价责任人对象ID-填报评价责任人对象ID不能为空",false);
                receptionServiceRes = nbSystemTestDomain.implementCalcReceivingField005(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        } else if ((!(reqDto != null && reqDto.getDataType() != null && reqDto.getDataType().equals("SUBJECTIVE_MARK")))) {
            //elseif(D4分析修复标准数据填报责任人对象ID(公共).数据点类型 不等于 主观评分)  69942

//ModelCode: receptionService
            ImplementCalcReceivingField005RespDto receptionServiceRes_2 = null;
            ImplementCalcReceivingField005ReqDto receptionServiceReq_1 = new ImplementCalcReceivingField005ReqDto();
            if (reqDto != null) {
                receptionServiceReq_1.setPersonLiableObjId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1865263_1_69945
            }

            /*M4接收填报评价责任人对象ID[9539]  用于特殊方法接收上游入参。 */
//    Assert.isNull(receptionServiceReq_1.getPersonLiableObjId(),"D4分析修复标准数据填报责任人对象ID(公共)-M4接收填报评价责任人对象ID-填报评价责任人对象ID不能为空",false);
            receptionServiceRes_2 = nbSystemTestDomain.implementCalcReceivingField005(receptionServiceReq_1);


            receptionServiceRes_1 = receptionServiceRes_2;
        }
        AnalysisRepairStandardPersonLiableObjIdComRespDto retData = new AnalysisRepairStandardPersonLiableObjIdComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setPersonLiableObjId(receptionServiceRes_1.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1865272_1
        }


        return retData;
    }

    /**
     * D4执行修复周期阶段资料对应标准数据时间切片(运维接口)[9846]
     * gen by moon at 6/22/2024, 10:10:44 AM
     */
    @Trace(operationName = "D4执行修复周期阶段资料对应标准数据时间切片(运维接口)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementRepairCycleStageDataCorrespondingStandardDataTimeSliceComRespDto implementRepairCycleStageDataCorrespondingStandardDataTimeSliceCom(ImplementRepairCycleStageDataCorrespondingStandardDataTimeSliceComReqDto reqDto) {


        //virtualUsage M4执行标准数据【循环开始】  70583
        //ModelCode: circulationCollections
        for (StandardDataDto circulationCollectionsRes : reqDto.getStandardDataList()) {

//virtualUsage D3查目标归属周期详情(公共)  70585
            QueryTargetBeCycleDetailComRespDto queryTargetBeCycleDetailComRespDto = null;
            QueryTargetBeCycleDetailComReqDto queryTargetBeCycleDetailComReqDto = new QueryTargetBeCycleDetailComReqDto();
            if (circulationCollectionsRes != null) {
                queryTargetBeCycleDetailComReqDto.setCycleId(circulationCollectionsRes.getPeriodId());//SimpleFieldAssign//sourceId:1886747_1_70585
                queryTargetBeCycleDetailComReqDto.setEntityId(circulationCollectionsRes.getEntityId());//SimpleFieldAssign//sourceId:1886749_1_70585
                queryTargetBeCycleDetailComReqDto.setParentSubMidCycleType(circulationCollectionsRes.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1886748_1_70585
            }

            /*D3查目标归属周期详情(公共)[9544]   */
            Assert.isNull(queryTargetBeCycleDetailComReqDto.getCycleId(), "D4执行修复周期阶段资料对应标准数据时间切片(运维接口)-D3查目标归属周期详情(公共)-归属周期ID不能为空", false);
            Assert.isNull(queryTargetBeCycleDetailComReqDto.getEntityId(), "D4执行修复周期阶段资料对应标准数据时间切片(运维接口)-D3查目标归属周期详情(公共)-归属内容表主键ID不能为空", false);
            Assert.isNull(queryTargetBeCycleDetailComReqDto.getParentSubMidCycleType(), "D4执行修复周期阶段资料对应标准数据时间切片(运维接口)-D3查目标归属周期详情(公共)-父子中过程周期类型不能为空", false);
            queryTargetBeCycleDetailComRespDto = fwAppTargetCalcClient.queryTargetBeCycleDetailCom(queryTargetBeCycleDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            if ((queryTargetBeCycleDetailComRespDto != null && queryTargetBeCycleDetailComRespDto.getTargetAttributionCycleId() != null)) {
                //if(D3查目标归属周期详情(公共).目标归属周期ID 值不等于空 )  70586

                boolean bOOLEAN;
                if (queryTargetBeCycleDetailComRespDto != null) {
                    OmsStandardDataResult omsStandardDataResult = new OmsStandardDataResult();
                    if (circulationCollectionsRes != null) {
                        omsStandardDataResult.setDataResultId(circulationCollectionsRes.getDataResultId());//SimpleFieldAssign//sourceId:1886786_1_70588
                    }
                    if (queryTargetBeCycleDetailComRespDto != null) {
                        omsStandardDataResult.setWorkCycleUpdateSlice(queryTargetBeCycleDetailComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1886788_1_70588
                    }

                    /*4-01-01修改标准数据[2860]   */
                    Assert.isNull(omsStandardDataResult.getDataResultId(), "D4执行修复周期阶段资料对应标准数据时间切片(运维接口)-4-01-01修改标准数据-数据结果ID 不能为空", false);
                    Assert.isNull(omsStandardDataResult.getWorkCycleUpdateSlice(), "D4执行修复周期阶段资料对应标准数据时间切片(运维接口)-4-01-01修改标准数据-工作周期更新切片不能为空", false);
                    bOOLEAN = mOmsStandardDataResultService.updateStandardData(omsStandardDataResult)/*vcase invoke 本地 method 方法调用;*/;


                }
            } else if ((queryTargetBeCycleDetailComRespDto != null && queryTargetBeCycleDetailComRespDto.getTargetAttributionCycleId() == null)) {
                //elseif(D3查目标归属周期详情(公共).目标归属周期ID 值等于空 )  70587

                ImplementDebugBusinessDataRedisComRespDto implementDebugBusinessDataRedisComRespDto = null;
                ImplementDebugBusinessDataRedisComReqDto implementDebugBusinessDataRedisComReqDto = new ImplementDebugBusinessDataRedisComReqDto();
                implementDebugBusinessDataRedisComReqDto.setBusinessDataObject("BUSINESS_DATA_OBJECT_TEST");//sourceId:1886804_1_70589
                implementDebugBusinessDataRedisComReqDto.setDebugScene("SINGLE_OBJECT");//CUSTOM_CONVENTION//sourceId:1886805_1_70589
                implementDebugBusinessDataRedisComReqDto.setWrongObjectDescribe("对不起，该标准数据找不到目标归属周期ID");//CUSTOM_CONVENTION//sourceId:1886806_1_70589
                if (circulationCollectionsRes != null) {
                    implementDebugBusinessDataRedisComReqDto.setCustomField11(circulationCollectionsRes.getDataResultId());//SimpleFieldAssign//sourceId:1886810_1_70589
                }

                /*D2执行DEBUG业务对象数据Redis(公共)[9660]   */
                Assert.isNull(implementDebugBusinessDataRedisComReqDto.getBusinessDataObject(), "D4执行修复周期阶段资料对应标准数据时间切片(运维接口)-D2执行DEBUG业务对象数据Redis(公共)-业务数据对象不能为空", false);
                Assert.isNull(implementDebugBusinessDataRedisComReqDto.getDebugScene(), "D4执行修复周期阶段资料对应标准数据时间切片(运维接口)-D2执行DEBUG业务对象数据Redis(公共)-DEBUG业务场景不能为空", false);
                Assert.isNull(implementDebugBusinessDataRedisComReqDto.getWrongObjectDescribe(), "D4执行修复周期阶段资料对应标准数据时间切片(运维接口)-D2执行DEBUG业务对象数据Redis(公共)-错误对象描述不能为空", false);
                Assert.isNull(implementDebugBusinessDataRedisComReqDto.getCustomField11(), "D4执行修复周期阶段资料对应标准数据时间切片(运维接口)-D2执行DEBUG业务对象数据Redis(公共)-数据结果ID不能为空", false);
                implementDebugBusinessDataRedisComRespDto = fwCompBusinessAtomClient.implementDebugBusinessDataRedisCom(implementDebugBusinessDataRedisComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
//virtualUsage M4-执行【循环结束】  70584
            //ModelCode: circulationEnd
        }

        ImplementRepairCycleStageDataCorrespondingStandardDataTimeSliceComRespDto retData = new ImplementRepairCycleStageDataCorrespondingStandardDataTimeSliceComRespDto();


        return retData;
    }

    /**
     * D4执行检测进度型指标标准数据合规性（运维接口）[9861]
     * gen by moon at 6/23/2024, 9:04:47 PM
     */
    @Trace(operationName = "D4执行检测进度型指标标准数据合规性（运维接口）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementInspectProgressObjectiveDataComplianceComRespDto implementInspectProgressObjectiveDataComplianceCom(ImplementInspectProgressObjectiveDataComplianceComReqDto reqDto) {


        //virtualUsage D4-1查询标准数据列表(公共)  70741
        QueryStandardDataListComRespDto queryStandardDataListComRespDto = null;
        QueryStandardDataListComReqDto queryStandardDataListComReqDto = new QueryStandardDataListComReqDto();
        queryStandardDataListComReqDto.setResultType("MANUAL_INPUT");//sourceId:1890750_1_70741
        queryStandardDataListComReqDto.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:1890902_1_70741
        queryStandardDataListComReqDto.setIsArchive("FALSE");//sourceId:1890752_1_70741
        queryStandardDataListComReqDto.setDataType("PROGRESS_VALUE");//sourceId:1890754_1_70741
        if (reqDto != null) {
            queryStandardDataListComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1890751_1_70741
            queryStandardDataListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1890753_1_70741
        }

        /*D4-1查询标准数据列表(公共)[4696]   */
        Assert.isNull(queryStandardDataListComReqDto.getResultType(), "D4执行检测进度型指标标准数据合规性（运维接口）-D4-1查询标准数据列表(公共)-结果产生类型不能为空", false);
        Assert.isNull(queryStandardDataListComReqDto.getDataUsageSceneCode(), "D4执行检测进度型指标标准数据合规性（运维接口）-D4-1查询标准数据列表(公共)-数据业务场景不能为空", false);
        Assert.isNull(queryStandardDataListComReqDto.getIsArchive(), "D4执行检测进度型指标标准数据合规性（运维接口）-D4-1查询标准数据列表(公共)-是否存档不能为空", false);
        Assert.isNull(queryStandardDataListComReqDto.getDataType(), "D4执行检测进度型指标标准数据合规性（运维接口）-D4-1查询标准数据列表(公共)-数据点类型不能为空", false);
        queryStandardDataListComRespDto = standardDataService.queryStandardDataListCom(queryStandardDataListComReqDto)/*vcase invoke isSameApp*/;


        if ((queryStandardDataListComRespDto != null && queryStandardDataListComRespDto.getStandardDataList() != null && queryStandardDataListComRespDto.getStandardDataList().size() > 0)) {
            //if(D4-1查询标准数据列表(公共).标准数据列表数据集条数 大于 0)  70742

//ModelCode: circulationCollections
            for (com.wicket.okrcalc.base.service.dto.common.StandardDataDto circulationCollectionsRes : queryStandardDataListComRespDto.getStandardDataList()) {

                if ((circulationCollectionsRes != null && circulationCollectionsRes.getBelongToContentTypeCode() != null && circulationCollectionsRes.getBelongToContentTypeCode().equals("OMS_TARGET_OBJECTIVE"))) {
                    //if(M4执行标准数据【循环开始】.数据归属内容表类型编码 等于 指标表)  70745

                    QueryTargetObjDetailComRespDto queryTargetObjDetailComRespDto = null;
                    QueryTargetObjDetailComReqDto queryTargetObjDetailComReqDto = new QueryTargetObjDetailComReqDto();
                    if (circulationCollectionsRes != null) {
                        queryTargetObjDetailComReqDto.setObjectiveId(circulationCollectionsRes.getBelongToContentId());//SimpleFieldAssign//sourceId:1890779_1_70746
                    }

                    /*D3-3查询指标详情(公共)[2794]   */
                    Assert.isNull(queryTargetObjDetailComReqDto.getObjectiveId(), "D4执行检测进度型指标标准数据合规性（运维接口）-D3-3查询指标详情(公共)-指标ID不能为空", false);
                    queryTargetObjDetailComRespDto = fwAppIndexSystemClient.queryTargetObjDetailCom(queryTargetObjDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                    if ((queryTargetObjDetailComRespDto != null && queryTargetObjDetailComRespDto.getTargetValueType() != null && queryTargetObjDetailComRespDto.getTargetValueType().equals("PROGRESS"))) {
                        //if(D3-3查询指标详情(公共).冗余指标业务类型 等于 进度型)  70747

                        OmsStandardDataResult omsStandardDataResult = null;
                        QueryStandardDataDetailReq queryStandardDataDetailReq = new QueryStandardDataDetailReq();
                        queryStandardDataDetailReq.setDataType("ACTUAL_VALUE");//sourceId:1890895_1_70748
                        queryStandardDataDetailReq.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:1890896_1_70748
                        queryStandardDataDetailReq.setResultType("MANUAL_INPUT");//sourceId:1890897_1_70748
                        queryStandardDataDetailReq.setIsArchive("FALSE");//sourceId:1890908_1_70748
                        if (circulationCollectionsRes != null) {
                            queryStandardDataDetailReq.setUpdateCycleId(circulationCollectionsRes.getUpdateCycleId());//SimpleFieldAssign//sourceId:1890899_1_70748
                            queryStandardDataDetailReq.setPeriodId(circulationCollectionsRes.getPeriodId());//SimpleFieldAssign//sourceId:1890898_1_70748
                            queryStandardDataDetailReq.setParentSubMidCycleType(circulationCollectionsRes.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1890900_1_70748
                            queryStandardDataDetailReq.setEntityId(circulationCollectionsRes.getEntityId());//SimpleFieldAssign//sourceId:1890901_1_70748
                        }

                        /*4-01-01查实际值标准数据详情[2696]   */
                        Assert.isNull(queryStandardDataDetailReq.getDataType(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01查实际值标准数据详情-数据点类型不能为空", false);
                        Assert.isNull(queryStandardDataDetailReq.getDataUsageSceneCode(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01查实际值标准数据详情-数据业务场景不能为空", false);
                        Assert.isNull(queryStandardDataDetailReq.getResultType(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01查实际值标准数据详情-结果产生类型不能为空", false);
                        Assert.isNull(queryStandardDataDetailReq.getUpdateCycleId(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01查实际值标准数据详情-更新周期ID不能为空", false);
                        Assert.isNull(queryStandardDataDetailReq.getPeriodId(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01查实际值标准数据详情-周期ID不能为空", false);
                        Assert.isNull(queryStandardDataDetailReq.getParentSubMidCycleType(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01查实际值标准数据详情-父子中周期类型不能为空", false);
                        Assert.isNull(queryStandardDataDetailReq.getEntityId(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01查实际值标准数据详情-归属内容表主键ID不能为空", false);
                        Assert.isNull(queryStandardDataDetailReq.getIsArchive(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01查实际值标准数据详情-是否存档不能为空", false);
                        omsStandardDataResult = mOmsStandardDataResultService.queryStandardDataDetail(queryStandardDataDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                        if ((omsStandardDataResult != null)) {
                            //if(4-01-01查实际值标准数据详情.出参 值不等于空 )  70749

                            boolean bOOLEAN;
                            if (omsStandardDataResult != null) {
                                OmsStandardDataResult omsStandardDataResult_2 = new OmsStandardDataResult();
                                if (omsStandardDataResult != null) {
                                    omsStandardDataResult_2.setDataResultId(omsStandardDataResult.getDataResultId());//SimpleFieldAssign//sourceId:1890943_1_70750
                                }
                                if (circulationCollectionsRes != null) {
                                    omsStandardDataResult_2.setDataResult(circulationCollectionsRes.getDataResult());//SimpleFieldAssign//sourceId:1890944_1_70750
                                }

                                /*4-01-01修改标准数据[2860]   */
                                Assert.isNull(omsStandardDataResult_2.getDataResultId(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01修改标准数据-数据结果ID 不能为空", false);
                                Assert.isNull(omsStandardDataResult_2.getDataResult(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01修改标准数据-数据值结果不能为空", false);
                                bOOLEAN = mOmsStandardDataResultService.updateStandardData(omsStandardDataResult_2)/*vcase invoke 本地 method 方法调用;*/;


                            }
                        } else if ((omsStandardDataResult == null)) {
                            //elseif(4-01-01查实际值标准数据详情.出参 值等于空 )  70751

                            OmsStandardDataResult omsStandardDataResult_3 = null;
                            QueryStandardDataDetailReq queryStandardDataDetailReq_1 = new QueryStandardDataDetailReq();
                            if (circulationCollectionsRes != null) {
                                queryStandardDataDetailReq_1.setDataResultId(circulationCollectionsRes.getDataResultId());//SimpleFieldAssign//sourceId:1891084_1_70752
                            }

                            /*4-01-01查进度值标准数据详情[2696]   */
                            Assert.isNull(queryStandardDataDetailReq_1.getDataResultId(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01查进度值标准数据详情-数据结果ID 不能为空", false);
                            omsStandardDataResult_3 = mOmsStandardDataResultService.queryStandardDataDetail(queryStandardDataDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


                            String string = null;
                            if (omsStandardDataResult_3 != null) {
                                OmsStandardDataResult omsStandardDataResult_5 = new OmsStandardDataResult();
                                omsStandardDataResult_5.setDataType("ACTUAL_VALUE");//sourceId:1891047_1_70753
                                if (omsStandardDataResult_3 != null) {
                                    omsStandardDataResult_5.setDataResult(omsStandardDataResult_3.getDataResult());//SimpleFieldAssign//sourceId:1891039_1_70753
                                    omsStandardDataResult_5.setUnit(omsStandardDataResult_3.getUnit());//SimpleFieldAssign//sourceId:1891043_1_70753
                                    omsStandardDataResult_5.setResultType(omsStandardDataResult_3.getResultType());//SimpleFieldAssign//sourceId:1891040_1_70753
                                    omsStandardDataResult_5.setParentSubMidCycleType(omsStandardDataResult_3.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1891064_1_70753
                                    omsStandardDataResult_5.setPeriodId(omsStandardDataResult_3.getPeriodId());//SimpleFieldAssign//sourceId:1891044_1_70753
                                    omsStandardDataResult_5.setCycleStartTime(omsStandardDataResult_3.getCycleStartTime());//SimpleFieldAssign//sourceId:1891058_1_70753
                                    omsStandardDataResult_5.setCycleEndTime(omsStandardDataResult_3.getCycleEndTime());//SimpleFieldAssign//sourceId:1891059_1_70753
                                    omsStandardDataResult_5.setCycleTypeCode(omsStandardDataResult_3.getCycleTypeCode());//SimpleFieldAssign//sourceId:1891046_1_70753
                                    omsStandardDataResult_5.setCycleTypeInstanceCode(omsStandardDataResult_3.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1891045_1_70753
                                    omsStandardDataResult_5.setUpdateCycleId(omsStandardDataResult_3.getUpdateCycleId());//SimpleFieldAssign//sourceId:1891065_1_70753
                                    omsStandardDataResult_5.setUpdateCycleStartTime(omsStandardDataResult_3.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1891074_1_70753
                                    omsStandardDataResult_5.setUpdateCycleEndTime(omsStandardDataResult_3.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1891075_1_70753
                                    omsStandardDataResult_5.setUpdateCycleTypeCode(omsStandardDataResult_3.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1891070_1_70753
                                    omsStandardDataResult_5.setWorkCycleUpdateSlice(omsStandardDataResult_3.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1891069_1_70753
                                    omsStandardDataResult_5.setStandardDataCalcCycleModel(omsStandardDataResult_3.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1891071_1_70753
                                    omsStandardDataResult_5.setDataUsageSceneCode(omsStandardDataResult_3.getDataUsageSceneCode());//SimpleFieldAssign//sourceId:1891073_1_70753
                                    omsStandardDataResult_5.setIsWorkCycleData(omsStandardDataResult_3.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1891076_1_70753
                                    omsStandardDataResult_5.setTableTypeCode(omsStandardDataResult_3.getTableTypeCode());//SimpleFieldAssign//sourceId:1891048_1_70753
                                    omsStandardDataResult_5.setEntityId(omsStandardDataResult_3.getEntityId());//SimpleFieldAssign//sourceId:1891049_1_70753
                                    omsStandardDataResult_5.setFromContentTableTypeCode(omsStandardDataResult_3.getFromContentTableTypeCode());//SimpleFieldAssign//sourceId:1891050_1_70753
                                    omsStandardDataResult_5.setFromContentEntityId(omsStandardDataResult_3.getFromContentEntityId());//SimpleFieldAssign//sourceId:1891051_1_70753
                                    omsStandardDataResult_5.setPersonLiableObjId(omsStandardDataResult_3.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1891052_1_70753
                                    omsStandardDataResult_5.setPersonLiableTypeCode(omsStandardDataResult_3.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1891055_1_70753
                                    omsStandardDataResult_5.setBizRoleObjId(omsStandardDataResult_3.getBizRoleObjId());//SimpleFieldAssign//sourceId:1891053_1_70753
                                    omsStandardDataResult_5.setBizRoleObjCode(omsStandardDataResult_3.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1891057_1_70753
                                    omsStandardDataResult_5.setBizRoleObjName(omsStandardDataResult_3.getBizRoleObjName());//SimpleFieldAssign//sourceId:1891054_1_70753
                                    omsStandardDataResult_5.setSubjectLifeCycle(omsStandardDataResult_3.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1891056_1_70753
                                    omsStandardDataResult_5.setBelongToPersonalIdentityId(omsStandardDataResult_3.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1891078_1_70753
                                    omsStandardDataResult_5.setBelongToPersonalIdentityTypeCode(omsStandardDataResult_3.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1891077_1_70753
                                    omsStandardDataResult_5.setBelongToPersonalIdentityRoleCode(omsStandardDataResult_3.getBelongToPersonalIdentityRoleCode());//SimpleFieldAssign//sourceId:1891092_1_70753
                                    omsStandardDataResult_5.setBelongToContentTypeCode(omsStandardDataResult_3.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1891060_1_70753
                                    omsStandardDataResult_5.setBelongToContentId(omsStandardDataResult_3.getBelongToContentId());//SimpleFieldAssign//sourceId:1891061_1_70753
                                    omsStandardDataResult_5.setExtendedField1(omsStandardDataResult_3.getExtendedField1());//SimpleFieldAssign//sourceId:1891066_1_70753
                                    omsStandardDataResult_5.setExtendedField2(omsStandardDataResult_3.getExtendedField2());//SimpleFieldAssign//sourceId:1891067_1_70753
                                    omsStandardDataResult_5.setExtendedField3(omsStandardDataResult_3.getExtendedField3());//SimpleFieldAssign//sourceId:1891079_1_70753
                                    omsStandardDataResult_5.setExtendedField4(omsStandardDataResult_3.getExtendedField4());//SimpleFieldAssign//sourceId:1891090_1_70753
                                    omsStandardDataResult_5.setExtendedField5(omsStandardDataResult_3.getExtendedField5());//SimpleFieldAssign//sourceId:1891091_1_70753
                                    omsStandardDataResult_5.setThemeContentTypeCode(omsStandardDataResult_3.getThemeContentTypeCode());//SimpleFieldAssign//sourceId:1891062_1_70753
                                    omsStandardDataResult_5.setThemeContentId(omsStandardDataResult_3.getThemeContentId());//SimpleFieldAssign//sourceId:1891063_1_70753
                                    omsStandardDataResult_5.setCalcStartTime(omsStandardDataResult_3.getCalcStartTime());//SimpleFieldAssign//sourceId:1891072_1_70753
                                    omsStandardDataResult_5.setEventBatchUpdateCode(omsStandardDataResult_3.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:1891089_1_70753
                                }

                                /*4-01-01新增标准数据[2856]   */
                                Assert.isNull(omsStandardDataResult_5.getDataResult(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-数据值结果不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getUnit(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-冗余单位不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getResultType(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-结果产生类型不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getParentSubMidCycleType(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-父子中周期类型不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getPeriodId(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-周期ID不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getCycleStartTime(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-周期开始时间不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getCycleEndTime(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-周期结束时间不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getCycleTypeCode(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-周期类型标识不能为空", false);
//Assert.isNull(omsStandardDataResult_5.getCycleTypeInstanceCode(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-周期类型实例标识不能为空",false);
                                Assert.isNull(omsStandardDataResult_5.getUpdateCycleId(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-更新周期ID不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getUpdateCycleStartTime(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-更新周期开始时间不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getUpdateCycleEndTime(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-更新周期结束时间不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getUpdateCycleTypeCode(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-更新周期类型标识不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getWorkCycleUpdateSlice(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-工作周期更新切片不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getStandardDataCalcCycleModel(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-计算周期五模型不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getDataUsageSceneCode(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-数据业务场景不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getIsWorkCycleData(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-是否工作周期数据不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getDataType(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-数据点类型不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getTableTypeCode(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-归属内容表类型编码不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getEntityId(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-归属内容表主键ID不能为空", false);
//Assert.isNull(omsStandardDataResult_5.getFromContentTableTypeCode(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-来自内容表类型编码不能为空",false);
//Assert.isNull(omsStandardDataResult_5.getFromContentEntityId(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-来自内容表主键ID不能为空",false);
                                Assert.isNull(omsStandardDataResult_5.getPersonLiableObjId(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-填报评价责任人对象ID不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getPersonLiableTypeCode(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-填报评价责任人身份类型编码不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getBizRoleObjId(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-填报评价责任人业务角色对象ID不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getBizRoleObjCode(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-填报评价责任人业务角色标识不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getBizRoleObjName(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-填报评价责任人业务角色对象名称不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getSubjectLifeCycle(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-主体生命周期不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getBelongToPersonalIdentityId(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-数据归属对象ID不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getBelongToPersonalIdentityTypeCode(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-数据归属对象类型编码不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getBelongToContentTypeCode(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-数据归属内容表类型编码不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getBelongToContentId(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-数据归属内容表主键ID不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getThemeContentTypeCode(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-主题内容类型编码不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getThemeContentId(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-主题内容ID不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getCalcStartTime(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-计算开始时间不能为空", false);
                                Assert.isNull(omsStandardDataResult_5.getEventBatchUpdateCode(), "D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-事务内数据更新批次标识不能为空", false);
                                string = mOmsStandardDataResultService.addStandardData(omsStandardDataResult_5)/*vcase invoke 本地 method 方法调用;*/;


                            }
                        }
                    }
                }
//ModelCode: circulationEnd
            }

        }
        ImplementInspectProgressObjectiveDataComplianceComRespDto retData = new ImplementInspectProgressObjectiveDataComplianceComRespDto();


        return retData;
    }

    /**
     * D4执行刷人工填报数据（运维-临时）[10238]
     * gen by moon at 9/22/2024, 10:35:47 PM
     */
    @Trace(operationName = "D4执行刷人工填报数据（运维-临时）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementBrushManualFullDataRespDto implementBrushManualFullData(ImplementBrushManualFullDataReqDto reqDto) {


        //virtualUsage M4-接收字段入参（计算使用）  72971
        //ModelCode: receptionService
        AddAcceptFieldRespDto receptionServiceRes = null;
        AddAcceptFieldReqDto receptionServiceReq = new AddAcceptFieldReqDto();
        receptionServiceReq.setDataResult(Double.valueOf("0"));//CUSTOM_CONVENTION//sourceId:2009406_1_72971
        if (reqDto != null) {
            receptionServiceReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2009138_1_72971
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2009189_1_72971
        }

        /*M4-接收字段入参（计算使用）[6392]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getCycleId(), "D4执行刷人工填报数据（运维-临时）-M4-接收字段入参（计算使用）-周期ID不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D4执行刷人工填报数据（运维-临时）-M4-接收字段入参（计算使用）-冗余评价模板ID不能为空", false);
        Assert.isNull(receptionServiceReq.getDataResult(), "D4执行刷人工填报数据（运维-临时）-M4-接收字段入参（计算使用）-数据值结果不能为空", false);
        receptionServiceRes = nbSystemTestDomain.addAcceptField(receptionServiceReq);


//virtualUsage D3查询目标归属周期列表(公共)  72960
        QueryCurAndAncestorTargetAttributionCycleListComRespDto queryCurAndAncestorTargetAttributionCycleListComRespDto = null;
        QueryCurAndAncestorTargetAttributionCycleListComReqDto queryCurAndAncestorTargetAttributionCycleListComReqDto = new QueryCurAndAncestorTargetAttributionCycleListComReqDto();
        queryCurAndAncestorTargetAttributionCycleListComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2009183_1_72960
        queryCurAndAncestorTargetAttributionCycleListComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:2009184_1_72960
        queryCurAndAncestorTargetAttributionCycleListComReqDto.setBelongToContentTypeCode("OMS_TARGET_OBJECTIVE");//sourceId:2009186_1_72960
        queryCurAndAncestorTargetAttributionCycleListComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2009188_1_72960
        if (reqDto != null) {
            queryCurAndAncestorTargetAttributionCycleListComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2009185_1_72960
            queryCurAndAncestorTargetAttributionCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2009187_1_72960
        }

        /*D3查询目标归属周期列表(公共)[9728]   */
        Assert.isNull(queryCurAndAncestorTargetAttributionCycleListComReqDto.getCycleId(), "D4执行刷人工填报数据（运维-临时）-D3查询目标归属周期列表(公共)-归属周期ID不能为空", false);
        Assert.isNull(queryCurAndAncestorTargetAttributionCycleListComReqDto.getEvaObjEntityId(), "D4执行刷人工填报数据（运维-临时）-D3查询目标归属周期列表(公共)-主树被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryCurAndAncestorTargetAttributionCycleListComReqDto.getEvaObjTypeCode(), "D4执行刷人工填报数据（运维-临时）-D3查询目标归属周期列表(公共)-主树被评对象类型编码不能为空", false);
        Assert.isNull(queryCurAndAncestorTargetAttributionCycleListComReqDto.getBelongToContentTypeCode(), "D4执行刷人工填报数据（运维-临时）-D3查询目标归属周期列表(公共)-数据归属内容表类型编码不能为空", false);
        Assert.isNull(queryCurAndAncestorTargetAttributionCycleListComReqDto.getEvaluationTemplateId(), "D4执行刷人工填报数据（运维-临时）-D3查询目标归属周期列表(公共)-冗余评价模板ID不能为空", false);
        Assert.isNull(queryCurAndAncestorTargetAttributionCycleListComReqDto.getSpaceId(), "D4执行刷人工填报数据（运维-临时）-D3查询目标归属周期列表(公共)-创建于空间ID不能为空", false);
        queryCurAndAncestorTargetAttributionCycleListComRespDto = fwAppTargetCalcClient.queryCurAndAncestorTargetAttributionCycleListCom(queryCurAndAncestorTargetAttributionCycleListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        if ((queryCurAndAncestorTargetAttributionCycleListComRespDto != null && queryCurAndAncestorTargetAttributionCycleListComRespDto.getTargetBelongCycleList() != null && queryCurAndAncestorTargetAttributionCycleListComRespDto.getTargetBelongCycleList().size() > 0)) {
            //if(D3查询目标归属周期列表(公共).目标归属周期列表数据集条数 大于 0)  72961

//ModelCode: circulationCollections
            for (TargetBelongCycleDto circulationCollectionsRes : queryCurAndAncestorTargetAttributionCycleListComRespDto.getTargetBelongCycleList()) {

                QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto = null;
                QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto = new QueryStandardDataDetailComReqDto();
                queryStandardDataDetailComReqDto.setDataType("ACTUAL_VALUE");//sourceId:2009387_1_72964
                queryStandardDataDetailComReqDto.setResultType("MANUAL_INPUT");//sourceId:2009388_1_72964
                queryStandardDataDetailComReqDto.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:2009389_1_72964
                queryStandardDataDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2009393_1_72964
                if (reqDto != null) {
                    queryStandardDataDetailComReqDto.setPeriodId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2009390_1_72964
                    queryStandardDataDetailComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2009392_1_72964
                }
                if (circulationCollectionsRes != null) {
                    queryStandardDataDetailComReqDto.setEntityId(circulationCollectionsRes.getEntityId());//SimpleFieldAssign//sourceId:2009391_1_72964
                }

                /*D4-1查实际值标准数据详情(公共)[2695]   */
                Assert.isNull(queryStandardDataDetailComReqDto.getPeriodId(), "D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-周期ID不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getDataType(), "D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-数据点类型不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getResultType(), "D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-结果产生类型不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getDataUsageSceneCode(), "D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-数据业务场景不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getEntityId(), "D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-归属内容表主键ID不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getThemeContentId(), "D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-主题内容ID不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getSubjectLifeCycle(), "D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-主体生命周期不能为空", false);
                queryStandardDataDetailComRespDto = standardDataService.queryStandardDataDetailCom(queryStandardDataDetailComReqDto)/*vcase invoke isSameApp*/;


                QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto_2 = null;
                QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto_1 = new QueryStandardDataDetailComReqDto();
                queryStandardDataDetailComReqDto_1.setDataType("PROGRESS_VALUE");//sourceId:2009395_1_72965
                queryStandardDataDetailComReqDto_1.setResultType("MANUAL_INPUT");//sourceId:2009396_1_72965
                queryStandardDataDetailComReqDto_1.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:2009397_1_72965
                queryStandardDataDetailComReqDto_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2009401_1_72965
                if (reqDto != null) {
                    queryStandardDataDetailComReqDto_1.setPeriodId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2009398_1_72965
                    queryStandardDataDetailComReqDto_1.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2009400_1_72965
                }
                if (circulationCollectionsRes != null) {
                    queryStandardDataDetailComReqDto_1.setEntityId(circulationCollectionsRes.getEntityId());//SimpleFieldAssign//sourceId:2009399_1_72965
                }

                /*D4-1查进度值标准数据详情(公共)[2695]   */
                Assert.isNull(queryStandardDataDetailComReqDto_1.getPeriodId(), "D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-周期ID不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto_1.getDataType(), "D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-数据点类型不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto_1.getResultType(), "D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-结果产生类型不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto_1.getDataUsageSceneCode(), "D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-数据业务场景不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto_1.getEntityId(), "D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-归属内容表主键ID不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto_1.getThemeContentId(), "D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-主题内容ID不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto_1.getSubjectLifeCycle(), "D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-主体生命周期不能为空", false);
                queryStandardDataDetailComRespDto_2 = standardDataService.queryStandardDataDetailCom(queryStandardDataDetailComReqDto_1)/*vcase invoke isSameApp*/;


                if ((circulationCollectionsRes != null && circulationCollectionsRes.getTargetValueType() != null && circulationCollectionsRes.getTargetValueType().equals("NUMBER_GROWTH") || circulationCollectionsRes != null && circulationCollectionsRes.getTargetValueType() != null && circulationCollectionsRes.getTargetValueType().equals("NUMBER_DECLINE")) && queryStandardDataDetailComRespDto != null && queryStandardDataDetailComRespDto.getDataResultId() != null && queryStandardDataDetailComRespDto_2 != null && queryStandardDataDetailComRespDto_2.getDataResultId() != null) {
                    //if((M4执行目标归属周期【循环开始】.冗余指标业务类型 等于 数量增长型 or M4执行目标归属周期【循环开始】.冗余指标业务类型 等于 数量降幅型))  72966

                    QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto_4 = null;
                    QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto_2 = new QueryStandardDataDetailComReqDto();
                    queryStandardDataDetailComReqDto_2.setDataType("PROGRESS_VALUE");//sourceId:2009395_1_72968
                    queryStandardDataDetailComReqDto_2.setResultType("MANUAL_INPUT");//sourceId:2009396_1_72968
                    queryStandardDataDetailComReqDto_2.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:2009397_1_72968
                    queryStandardDataDetailComReqDto_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2009401_1_72968
                    if (circulationCollectionsRes != null) {
                        queryStandardDataDetailComReqDto_2.setPeriodId(circulationCollectionsRes.getPreviousCycleId());//SimpleFieldAssign//sourceId:2009398_1_72968
                        queryStandardDataDetailComReqDto_2.setEntityId(circulationCollectionsRes.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2009399_1_72968
                    }
                    if (reqDto != null) {
                        queryStandardDataDetailComReqDto_2.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2009400_1_72968
                    }

                    /*D4-1查进度值标准数据详情(公共)[2695]   */
                    Assert.isNull(queryStandardDataDetailComReqDto_2.getPeriodId(), "D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-周期ID不能为空", false);
                    Assert.isNull(queryStandardDataDetailComReqDto_2.getDataType(), "D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-数据点类型不能为空", false);
                    Assert.isNull(queryStandardDataDetailComReqDto_2.getResultType(), "D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-结果产生类型不能为空", false);
                    Assert.isNull(queryStandardDataDetailComReqDto_2.getDataUsageSceneCode(), "D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-数据业务场景不能为空", false);
                    Assert.isNull(queryStandardDataDetailComReqDto_2.getEntityId(), "D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-归属内容表主键ID不能为空", false);
                    Assert.isNull(queryStandardDataDetailComReqDto_2.getThemeContentId(), "D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-主题内容ID不能为空", false);
                    Assert.isNull(queryStandardDataDetailComReqDto_2.getSubjectLifeCycle(), "D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-主体生命周期不能为空", false);
                    queryStandardDataDetailComRespDto_4 = standardDataService.queryStandardDataDetailCom(queryStandardDataDetailComReqDto_2)/*vcase invoke isSameApp*/;


                    if ((queryStandardDataDetailComRespDto_4 != null && queryStandardDataDetailComRespDto_4.getDataResultId() != null)) {
                        //if(D4-1查上一周期进度值标准数据详情(公共).数据结果ID  值不等于空 )  72977

                        boolean bOOLEAN;
                        if (queryStandardDataDetailComRespDto_2 != null && queryStandardDataDetailComRespDto_4 != null) {
                            OmsStandardDataResult omsStandardDataResult = new OmsStandardDataResult();
                            if (queryStandardDataDetailComRespDto_2 != null) {
                                omsStandardDataResult.setDataResultId(queryStandardDataDetailComRespDto_2.getDataResultId());//SimpleFieldAssign//sourceId:2009404_1_72978
                            }
                            if (queryStandardDataDetailComRespDto_4 != null) {
                                omsStandardDataResult.setDataResult(queryStandardDataDetailComRespDto_4.getDataResult());//SimpleFieldAssign//sourceId:2009405_1_72978
                            }
                            if (receptionServiceRes != null) {
                                omsStandardDataResult.setChangeFromLastValue(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009410_1_72978
                                omsStandardDataResult.setChangeFromLastRatio(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009411_1_72978
                                omsStandardDataResult.setUpdateCycleChangeFromLastValue(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009412_1_72978
                                omsStandardDataResult.setUpdateCycleChangeFromLastRatio(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009413_1_72978
                            }

                            /*4-01-01修改标准数据[2860]   */
                            Assert.isNull(omsStandardDataResult.getDataResultId(), "D4执行刷人工填报数据（运维-临时）-4-01-01修改标准数据-数据结果ID 不能为空", false);
                            Assert.isNull(omsStandardDataResult.getDataResult(), "D4执行刷人工填报数据（运维-临时）-4-01-01修改标准数据-数据值结果不能为空", false);
                            bOOLEAN = mOmsStandardDataResultService.updateStandardData(omsStandardDataResult)/*vcase invoke 本地 method 方法调用;*/;


                        }
                        boolean bOOLEAN_1;
                        if (queryStandardDataDetailComRespDto != null) {
                            OmsStandardDataResult omsStandardDataResult_1 = new OmsStandardDataResult();
                            if (queryStandardDataDetailComRespDto != null) {
                                omsStandardDataResult_1.setDataResultId(queryStandardDataDetailComRespDto.getDataResultId());//SimpleFieldAssign//sourceId:2009404_1_72979
                            }
                            if (receptionServiceRes != null) {
                                omsStandardDataResult_1.setDataResult(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009405_1_72979
                                omsStandardDataResult_1.setChangeFromLastValue(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009410_1_72979
                                omsStandardDataResult_1.setChangeFromLastRatio(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009411_1_72979
                                omsStandardDataResult_1.setUpdateCycleChangeFromLastValue(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009412_1_72979
                                omsStandardDataResult_1.setUpdateCycleChangeFromLastRatio(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009413_1_72979
                            }

                            /*4-01-01修改标准数据[2860]   */
                            Assert.isNull(omsStandardDataResult_1.getDataResultId(), "D4执行刷人工填报数据（运维-临时）-4-01-01修改标准数据-数据结果ID 不能为空", false);
                            Assert.isNull(omsStandardDataResult_1.getDataResult(), "D4执行刷人工填报数据（运维-临时）-4-01-01修改标准数据-数据值结果不能为空", false);
                            bOOLEAN_1 = mOmsStandardDataResultService.updateStandardData(omsStandardDataResult_1)/*vcase invoke 本地 method 方法调用;*/;


                        }
                    }


                } else if ((circulationCollectionsRes != null && circulationCollectionsRes.getTargetValueType() != null && circulationCollectionsRes.getTargetValueType().equals("PERCENTAGE_GROWTH") || circulationCollectionsRes != null && circulationCollectionsRes.getTargetValueType() != null && circulationCollectionsRes.getTargetValueType().equals("PERCENTAGE_DECLINE") || circulationCollectionsRes != null && circulationCollectionsRes.getTargetValueType() != null && circulationCollectionsRes.getTargetValueType().equals("PROGRESS") || circulationCollectionsRes != null && circulationCollectionsRes.getTargetValueType() != null && circulationCollectionsRes.getTargetValueType().equals("RATIO_GROWTH") || circulationCollectionsRes != null && circulationCollectionsRes.getTargetValueType() != null && circulationCollectionsRes.getTargetValueType().equals("RATIO_DECLINE")) && queryStandardDataDetailComRespDto != null && queryStandardDataDetailComRespDto.getDataResultId() != null && queryStandardDataDetailComRespDto_2 != null && queryStandardDataDetailComRespDto_2.getDataResultId() != null) {
                    //elseif((M4执行目标归属周期【循环开始】.冗余指标业务类型 等于 百分比增长型 or M4执行目标归属周期【循环开始】.冗余指标业务类型 等于 百分比降幅型 or M4执行目标归属周期【循环开始】.冗余指标业务类型 等于 进度型 or M4执行目标归属周期【循环开始】.冗余指标业务类型 等于 比率增长型 or M4执行目标归属周期【循环开始】.冗余指标业务类型 等于 比率降幅型))  72972

                    QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto_5 = null;
                    QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto_3 = new QueryStandardDataDetailComReqDto();
                    queryStandardDataDetailComReqDto_3.setDataType("ACTUAL_VALUE");//sourceId:2009387_1_72973
                    queryStandardDataDetailComReqDto_3.setResultType("MANUAL_INPUT");//sourceId:2009388_1_72973
                    queryStandardDataDetailComReqDto_3.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:2009389_1_72973
                    queryStandardDataDetailComReqDto_3.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2009393_1_72973
                    if (circulationCollectionsRes != null) {
                        queryStandardDataDetailComReqDto_3.setPeriodId(circulationCollectionsRes.getPreviousCycleId());//SimpleFieldAssign//sourceId:2009390_1_72973
                        queryStandardDataDetailComReqDto_3.setEntityId(circulationCollectionsRes.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2009391_1_72973
                    }
                    if (reqDto != null) {
                        queryStandardDataDetailComReqDto_3.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2009392_1_72973
                    }

                    /*D4-1查实际值标准数据详情(公共)[2695]   */
                    Assert.isNull(queryStandardDataDetailComReqDto_3.getPeriodId(), "D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-周期ID不能为空", false);
                    Assert.isNull(queryStandardDataDetailComReqDto_3.getDataType(), "D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-数据点类型不能为空", false);
                    Assert.isNull(queryStandardDataDetailComReqDto_3.getResultType(), "D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-结果产生类型不能为空", false);
                    Assert.isNull(queryStandardDataDetailComReqDto_3.getDataUsageSceneCode(), "D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-数据业务场景不能为空", false);
                    Assert.isNull(queryStandardDataDetailComReqDto_3.getEntityId(), "D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-归属内容表主键ID不能为空", false);
                    Assert.isNull(queryStandardDataDetailComReqDto_3.getThemeContentId(), "D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-主题内容ID不能为空", false);
                    Assert.isNull(queryStandardDataDetailComReqDto_3.getSubjectLifeCycle(), "D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-主体生命周期不能为空", false);
                    queryStandardDataDetailComRespDto_5 = standardDataService.queryStandardDataDetailCom(queryStandardDataDetailComReqDto_3)/*vcase invoke isSameApp*/;


                    if ((queryStandardDataDetailComRespDto_5 != null && queryStandardDataDetailComRespDto_5.getDataResultId() != null)) {
                        //if(D4-1查上一周期实际值(公共).数据结果ID  值不等于空 )  72980

                        boolean bOOLEAN_2;
                        if (queryStandardDataDetailComRespDto != null && queryStandardDataDetailComRespDto_5 != null) {
                            OmsStandardDataResult omsStandardDataResult_2 = new OmsStandardDataResult();
                            if (queryStandardDataDetailComRespDto != null) {
                                omsStandardDataResult_2.setDataResultId(queryStandardDataDetailComRespDto.getDataResultId());//SimpleFieldAssign//sourceId:2009404_1_72981
                            }
                            if (queryStandardDataDetailComRespDto_5 != null) {
                                omsStandardDataResult_2.setDataResult(queryStandardDataDetailComRespDto_5.getDataResult());//SimpleFieldAssign//sourceId:2009405_1_72981
                            }
                            if (receptionServiceRes != null) {
                                omsStandardDataResult_2.setChangeFromLastValue(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009410_1_72981
                                omsStandardDataResult_2.setChangeFromLastRatio(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009411_1_72981
                                omsStandardDataResult_2.setUpdateCycleChangeFromLastValue(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009412_1_72981
                                omsStandardDataResult_2.setUpdateCycleChangeFromLastRatio(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009413_1_72981
                            }

                            /*4-01-01修改标准数据[2860]   */
                            Assert.isNull(omsStandardDataResult_2.getDataResultId(), "D4执行刷人工填报数据（运维-临时）-4-01-01修改标准数据-数据结果ID 不能为空", false);
                            Assert.isNull(omsStandardDataResult_2.getDataResult(), "D4执行刷人工填报数据（运维-临时）-4-01-01修改标准数据-数据值结果不能为空", false);
                            bOOLEAN_2 = mOmsStandardDataResultService.updateStandardData(omsStandardDataResult_2)/*vcase invoke 本地 method 方法调用;*/;


                        }
                    }


                    QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto_6 = null;
                    QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto_4 = new QueryStandardDataDetailComReqDto();
                    queryStandardDataDetailComReqDto_4.setDataType("PROGRESS_VALUE");//sourceId:2009395_1_72975
                    queryStandardDataDetailComReqDto_4.setResultType("MANUAL_INPUT");//sourceId:2009396_1_72975
                    queryStandardDataDetailComReqDto_4.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:2009397_1_72975
                    queryStandardDataDetailComReqDto_4.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2009401_1_72975
                    if (circulationCollectionsRes != null) {
                        queryStandardDataDetailComReqDto_4.setPeriodId(circulationCollectionsRes.getPreviousCycleId());//SimpleFieldAssign//sourceId:2009398_1_72975
                        queryStandardDataDetailComReqDto_4.setEntityId(circulationCollectionsRes.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2009399_1_72975
                    }
                    if (reqDto != null) {
                        queryStandardDataDetailComReqDto_4.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2009400_1_72975
                    }

                    /*D4-1查进度值标准数据详情(公共)[2695]   */
                    Assert.isNull(queryStandardDataDetailComReqDto_4.getPeriodId(), "D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-周期ID不能为空", false);
                    Assert.isNull(queryStandardDataDetailComReqDto_4.getDataType(), "D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-数据点类型不能为空", false);
                    Assert.isNull(queryStandardDataDetailComReqDto_4.getResultType(), "D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-结果产生类型不能为空", false);
                    Assert.isNull(queryStandardDataDetailComReqDto_4.getDataUsageSceneCode(), "D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-数据业务场景不能为空", false);
                    Assert.isNull(queryStandardDataDetailComReqDto_4.getEntityId(), "D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-归属内容表主键ID不能为空", false);
                    Assert.isNull(queryStandardDataDetailComReqDto_4.getThemeContentId(), "D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-主题内容ID不能为空", false);
                    Assert.isNull(queryStandardDataDetailComReqDto_4.getSubjectLifeCycle(), "D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-主体生命周期不能为空", false);
                    queryStandardDataDetailComRespDto_6 = standardDataService.queryStandardDataDetailCom(queryStandardDataDetailComReqDto_4)/*vcase invoke isSameApp*/;


                    if ((queryStandardDataDetailComRespDto_6 != null && queryStandardDataDetailComRespDto_6.getDataResultId() != null)) {
                        //if(D4-1查上一周期进度值(公共).数据结果ID  值不等于空 )  72982

                        boolean bOOLEAN_3;
                        if (queryStandardDataDetailComRespDto_2 != null && queryStandardDataDetailComRespDto_6 != null) {
                            OmsStandardDataResult omsStandardDataResult_3 = new OmsStandardDataResult();
                            if (queryStandardDataDetailComRespDto_2 != null) {
                                omsStandardDataResult_3.setDataResultId(queryStandardDataDetailComRespDto_2.getDataResultId());//SimpleFieldAssign//sourceId:2009404_1_72983
                            }
                            if (queryStandardDataDetailComRespDto_6 != null) {
                                omsStandardDataResult_3.setDataResult(queryStandardDataDetailComRespDto_6.getDataResult());//SimpleFieldAssign//sourceId:2009405_1_72983
                            }
                            if (receptionServiceRes != null) {
                                omsStandardDataResult_3.setChangeFromLastValue(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009410_1_72983
                                omsStandardDataResult_3.setChangeFromLastRatio(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009411_1_72983
                                omsStandardDataResult_3.setUpdateCycleChangeFromLastValue(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009412_1_72983
                                omsStandardDataResult_3.setUpdateCycleChangeFromLastRatio(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009413_1_72983
                            }

                            /*4-01-01修改标准数据[2860]   */
                            Assert.isNull(omsStandardDataResult_3.getDataResultId(), "D4执行刷人工填报数据（运维-临时）-4-01-01修改标准数据-数据结果ID 不能为空", false);
                            Assert.isNull(omsStandardDataResult_3.getDataResult(), "D4执行刷人工填报数据（运维-临时）-4-01-01修改标准数据-数据值结果不能为空", false);
                            bOOLEAN_3 = mOmsStandardDataResultService.updateStandardData(omsStandardDataResult_3)/*vcase invoke 本地 method 方法调用;*/;


                        }
                    }


                }
//ModelCode: circulationEnd
            }

        }
        ImplementBrushManualFullDataRespDto retData = new ImplementBrushManualFullDataRespDto();


        return retData;
    }

    //
}
